Tcl, 128 bytes

proc R s {join [lmap c [split $s ""] {expr {[string is alp $c]?[format %c [expr [set x [scan $c %c]]>109?$x-13:$x+13]]:$c}}] ""}

Try it online!

Seems to be a bit more golfable to me.

Raku (Perl 6) (rakudo), 69 bytes

{.trans('A'..'Z'=>('N'..'Z','A'..'M'),'a'..'z'=>('n'..'z','a'..'m'))}

Attempt This Online!

Note that this doesn't run on ATO's version of Raku.

{.trans(                         # works like tr
'A'..'Z'=>('N'..'Z','A'..'M')    # "manual" no math 
,'a'..'z'=>('n'..'z','a'..'m'))} # rotation

Z80, 23 bytes

Input location in hl, null-terminated. Clobbers de. Transforms in-place.

7E B7 C8 CB AF D6 41 FE 1A 30 09 FE 0E 30 02 C6
1A C6 34 77 23 18 E9

Disassembled:

f:
    ld  a,(hl)      // 7E
    or  a           // B7
    ret z           // C8
    res 5,a         // CB AF
    sub 65          // D6 41
    cp  26          // FE 1A
    jr  nc,s        // 30 ??
    cp  14          // FE 0E
    jr  nc,b        // 30 02
    add 26          // C6 1A
b:
    add 52          // C6 34
    ld  (hl),a      // 77
s:
    inc hl          // 23
    jr  f           // 18 ??

Vyxal 3, 10 bytes

-1 byte: complained to lyxal that ¨ didn't work correctly on ↺ and he fixed it lol

kL:½¨13↺“y

kL:½¨13↺“y­⁡​‎‎⁡⁠⁡‏⁠‎⁡⁠⁢‏‏​⁡⁠⁡‌⁢​‎‎⁡⁠⁣‏⁠‎⁡⁠⁤‏‏​⁡⁠⁡‌⁣​‎‎⁡⁠⁢⁡‏⁠‎⁡⁠⁢⁢‏⁠‎⁡⁠⁢⁣‏⁠‎⁡⁠⁢⁤‏‏​⁡⁠⁡‌⁤​‎‎⁡⁠⁣⁡‏‏​⁡⁠⁡‌⁢⁡​‎‎⁡⁠⁣⁢‏‏​⁡⁠⁡‌­
kL          # ‎⁡"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
  :½        # ‎⁢duplicate and split the copy in 2 halves
    ¨13↺    # ‎⁣rotate each half by 13 spaces
        “   # ‎⁤‎⁤join the 2 halves
         y  # ‎⁢⁡‎⁢⁡transliterate the input
💎

Created with the help of Luminespire.

<script type="vyxal3">
kL:½¨13↺“y
</script>
<script>
    args=[["Hello, world!"],["Code Golf and Coding Challenges is awesome."],["Mod abuse!1!!1"]]
</script>
<script src="https://themoonisacheese.github.io/snippeterpreter/snippet.js" type="module"/>

Uiua^SBCS, 30 bytes

a←+@A⇡26
⍜(⌵|⍥(⊡:↻13a-@A)∊:a.)

Try it online!

Explanation

a←+@A⇡26  ⍜(⌵|⍥(⊡:↻13a-@A)∊:a.)
a←+@A⇡26                        stores the uppercase alphabet in the variable `a`
          ⍜(⌵|                ) turn the array uppercase, and before reversing that:
                          ∊:a.  make a separate array for which characters are alphabetic
              ⍥(         )      for all the ones, modify the corresponding letter like this:
                      -@A       get the order of the letter in the alphabet minus one
                  ↻13a          rotate the letters of the alphabet by 13
                ⊡:              replace the number with the corresponding letter

Atto-8 Machine Code, 23 bytes

Decoded as hex:

E8 00 E0 C0 20 A0 61 84 00 0D 85 0D 90 0D 85 F2 90 D0 80 00 E1 01 E3

Commented disassembly listing:

# Generated by Dasm

main!
  nop @dyn        # padding for alignment
  x00 lda         # read from standard input
  ld0 x20 orr     # clone and convert to lowercase
  x61 sub         # map lowercase alphabet to 0-25
  x00             # default offset is 0
  x0D su2 x0D iff # if between a-m, offset is 13
  x0D su2 xF2 iff # if between n-z, offset is -13
  st0 add         # add offset to original input
  x00 sta         # write to standard output
  x01 sti         # loop back to start

JavaScript ES6 (155 bytes)

Here is a Caesar cipher that preserves case in in ES6.

// 155 bytes
r=s=>((f,n,m,u,l)=>[...s].map(c=>(x=>x>=u&&x<=u+n?f((x-u+m)%n+u):x>=l&&x<=l+n?f((x-l+m)%n+l):c)(c.charCodeAt())).join(''))(String.fromCharCode,26,13,65,97)

// Begin unit tests
mocha.setup('bdd')
const { expect } = chai
const testCases = [{
  input: "Hello, world!",
  output: "Uryyb, jbeyq!",
}, {
  input: "Code Golf and Coding Challenges is awesome.",
  output: "Pbqr Tbys naq Pbqvat Punyyratrf vf njrfbzr.",
}, {
  input: "Mod abuse!1!!1",
  output: "Zbq nohfr!1!!1",
}]
describe('Caesar cipher (ROT13)', () => {
    it('are all equal', () => {
    for (let { input, output } of testCases) {
      expect(r(input)).to.equal(output)
    }
  })
})
mocha.run()

<link href="https://cdnjs.cloudflare.com/ajax/libs/mocha/2.3.4/mocha.css" rel="stylesheet"/>
<script src="https://cdnjs.cloudflare.com/ajax/libs/chai/3.4.1/chai.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/mocha/2.3.4/mocha.js"></script>
<div id="mocha"></div>

Here is one that is 187 bytes (+32 bytes), but no code duplication:

r=s=>((b,f,n,m,u,l)=>[...s].map(c=>(x=>b(u,x,n)?f(u,x,n,m):b(l,x,n)?f(l,x,n,m):c)(c.charCodeAt())).join(''))((v,x,n)=>x>=v&&x<=v+n,(v,x,n,m)=>String.fromCharCode((x-v+m)%n+v),26,13,65,97)

At 192 bytes (+37 bytes), this one is a bit larger, but it builds a lookup and does regex replace:

r=s=>(l=>s.replace(/\w/g,c=>l[c]))(((f,z)=>f(z.map(c=>c.toLowerCase()),f(z,{})))((s,o)=>s.reduce((m,c,i)=>({...m,[c]:s[(i+13)%26]}),o),Array.from({length:26},(_,i)=>String.fromCharCode(i+65))))

Python + Rot13, 23 Bytes

from Rot13 import*
func

There is a package dedicated to this, but looking at the source code of the package, it is not well written...

Thunno 2, 1 byte

V

Attempt This Online!

Built-in solution.

Thunno 2, 12 bytes

kĠD½13ȷẒJsdṆ

Attempt This Online!

Thunno 2 J, 20 bytes

ıÐA?Ä12+26%97+Csfh?R

Attempt This Online!

Non built-in solutions.

Explanations

kĠD½13ȷẒJsdṆ  # Implicit input
kĠD           # Push the string [A-Za-z] and duplicate
   ½          # Halve it to yield [[A-Z], [a-z]]
      ȷ       # To each string in the pair:
    13 Ẓ      #  Rotate it 13 places to the right
              # (We now have [[N-ZA-M], [n-za-m]])
        J     # Join it into [N-ZA-Mn-za-m]
         sd   # Swap and cast to a list of characters
           Ṇ  # Transliterate the input string
              # Implicit output

ıÐA?Ä12+26%97+Csfh?R  # Implicit input
ı                     # Map over the input string:
 Ð                    #  Triplicate the current character
  A                   #  Pop one copy and check if it's alphabetic
   ?                  #  If it is:
    Ä                 #   Pop another copy and push its 1-based index in the alphabet
     12+              #   Add 12 to this number
        26%           #   Mod this number by 26
           97+        #   Add 97 to this number
              C       #   And convert it to a character
               s      #   Swap so the loop character is back on top
                fh    #   Pop it and check if it's uppercase
                  ?   #   If it is:
                   R  #    Uppercase the character on the top of the stack
                      #   Otherwise, the lowercase character stays on top
                      #  Otherwise, the loop character stays on top
                      # Implicit output, joined

Thunno, \$ 2 \log_{256}(96) \approx \$ 1.65 bytes

ZY

Attempt This Online!

Builtins FTW!

Zsh, 79 bytes

Builtins only. Try it Online!

for k (${(s::)1})printf ${k/[A-Za-z]/${(#)$((z=#k<91?0:32,65+z+(#k-52-z)%26))}}

Explanation

for k (${(s::)1})  # for each letter $k of the argument $1, loop
&&printf ${..}     # and print the value of expression ${..}, per `man zshexpn`
${k/[A-Za-z]/      # if $k is a letter, replace it with the following stuff,
                   #    otherwise leave it (implicit)
${(#)..}           # convert decimal (in the following expression) to ascii char
$((..))            # math expression
                   #    n.b.: #k is the ascii value (ord) of $k
#k<91?             # ternary: if #k<91, i.e $k is uppercase
65+(#k-52)%26      #    rotate uppercase
:97+(#k-84)%26     #    otherwise, rotate lowercase

_{Previous solutions: 126, 112, 106, 99, 88, 82
Initial (wrong) solutions: 56, 83b}

Assembly (MIPS, SPIM), 122 bytes

main:li$2 12
syscall
abs$4 $2
and$2 95
sub$2'A'
bgtu$2 25p
sub$4 13
bge$2 13p
add$4 26
p:li$2 11
syscall
bne$4 10main
j$ra

Try it online!

Input is a single line from stdin, output is printed to stdout.

Pretty similar to the other ASM versions as that is the best way on baremetal.

main:
.Lloop:
    li    $v0, 12            # READ CHARACTER
    syscall                  # v0 = getchar() or '\n'
    abs    $a0, $v0          # Save copy to a0 (abs is shorter than move for positive)
    and    $v0, 0x5F         # Clear bit 6 to convert lowercase to uppercase
    sub    $v0, 'A'          # Try to convert to number.
    bgtu   $v0, 25, .Lprint  # Non-letters will be < 0 or > 25, test with unsigned > 25
    sub    $a0, 13           # Subtract 13 to rotate left
    bge    $v0, 13, .Lprint  # If the letter-to-number was < 13...
    add    $a0, 26           # Add 26 to revert the left rotation and rotate right
.Lprint:
    li     $v0, 11           # 11 = PRINT CHARACTER
    syscall                  # putchar(a0)
    bne    $a0, '\n', .Lloop # Loop if not end of line
    j      $ra               # Return from main

K (ngn/k), 40 bytes

`c$@[!256;c@!26;:;(c:"aA"+\:)26!-13+!26]

Try it online!

><>, 49 bytes

0i::"{`"@(@)*84**-::"AZ"@(@)+:}?$"4"-2d*%"A"+{?$o

Try it online

Explanation

0i
On each loop we initialize the stack with 0 and an input character.
The 0 will be used as a dummy to perform rot-13 operations on when the input isn't a letter.

::"{`"@(@)*84**-
Convert lowercase letters into uppercase for easier future operations.

::"AZ"@(@)+:}?$
If the character isn't an uppercase letter, use the 0 instead.

"4"-2d*%"A"+
ROT-13 operation. Subtract 52, mod by 13 and add 65 to get an uppercase letter.

{?$
If the character wasn't an uppercase before the ROT-13 operations, use the saved character instead.

o
Print as a character.

Python 3, 60 bytes

import this
print("".join(this.d.get(c,c)for c in input()))

Alice, 129 bytes

vv2++3a-A'<
 a    > Ko= h-A'.<
 #  >@o Ko<>.'Zh-=oK
>wI.=>.'a-h=oK Ko<
 *  >^#va2++3a-a'<
 6    +*   >.'zh-=oK
 >+%'A^>6+%'a+oKo<

Try it online!

Ungolfed

v                      >oK
                 >.'A-h=oK
    >@     >.'Zh-=oK   >'A-a3++2a*6+%'A+oK
                 >oK
>wI.=>.'a-h=oK
                 >'a-a3++2a*6+%'a+oK
    >^     >.'zh-=oK
                 >oK

SM83/Z80, 29 bytes

Input string at (de), output to (hl).

• SM83 version

1A 13 47 CB AF D6 41 38
0E FE 1A 30 0A FE 0D 78
38 02 D6 1A C6 0D 47 78
22 B7 20 E4 C9

• Z80 version (changes in »German guillemets« except for second bytes of jr for same effective offset¹)

1A 13 47 CB AF D6 41 38
10 FE 1A 30 0C FE 0D 78
38 04 D6 1A C6 0D 47»70
23 04 10«E6 C9

Disassembly and explanation:

rot13:
    ld a,(de)       ; 1A        load character
    inc de          ; 13        increment
    ld b,a          ; 47        save copy
    res 5,a         ; CB AF     clear fifth bit
    sub 65          ; D6 41     subtract 'A'
    jr c,put        ; 38 0E/10  if borrowed, wasn't letter
    cp 26           ; FE 1A     is it 26 or more now?
    jr nc,put       ; 30 0A/0C  if didn't borrow, wasn't letter
    cp 13           ; FE 0D     compare against 13
    ld a,b          ; 78        load original
    jr c,notsub     ; 38 02/04  if carry, was greater than 13
    sub 26          ; D6 1A     subtract 26 if was greater
notsub:
    add 13          ; C6 0D     add 13 either way
    ld b,a          ; 47        store into b
put:                ;           b now contains rot13 version
#ifdef SM83
    ld a,b          ; 78        move into a
    ld (hl+),a      ; 22        store and increment
    or a            ; B7        test if zero
    jr nz,rot13     ; 20 E4     if not, loop
#else
    ld (hl),b       ; 70        store
    inc hl          ; 23        and increment
    inc b           ; 04        if b was 0, it's now 1
    djnz rot13      ; 10 E6     jump back if b is 1 (and decrement)
#endif
    ret             ; C9        return

It's a bit interesting that both CPUs have a way of saving a byte that the other doesn't. The SM83 has autoincrement addressing, while the Z80 has a way to jump if b is 1.

¹ Apparently Z80 relative jump instructions are measured from the start, while SM83's are from the end. (So 18 00 is an infinite loop for Z80 and a three-cycle two-byte no-op for SM83.)

JavaScript (Node.js), 65 bytes

o=>(b=Buffer)(b(o).map(c=>c%32<26&c>64?(c%32+13)%26+c-c%32:c))+''

Try it online!

o=>(                    // Define a function taking o and r
  b = Buffer            // Assign b to Buffer
)(                      // And call on...
  b(o).map(c=>          // a Buffer of the charcodes of o, mapped to...
    c%32<26&c>64        // If the character is alphabetical - charcode%32 is less than 26, charcode is >64
      ?                 // Then
    (c%32+13)%26+c-c%32 // Rot-13 the character - Mod 32, add 13, mod 26, add correct number depending on whether it's uppercase of lowercase.
    :c)                 // Else return the original string
 ) + ''                 // Coerce to string

C (clang), 200 164 113 86 bytes

main(){char*s,*t=s;for(gets(s);*s;s++)isalpha(*s)?*s+=(*s&~32)<78?13:-13:0;printf(t);}

Try it online!

This uses a for-loop which converts each letter into ROT13 using their ASCII values to use lesser bytes. scanf()'s parameters are now longer to include spaces in the string, since the previous code revision can't take spaces for input, so now it's longer.

Thanks to ceiling cat for golfing 36 bytes. Thanks to EasyasPi, with the help of ceilingcat, for golfing 51 bytes. Thanks to a stone arachnid for golfing 27 bytes.

Ly, 65 bytes

ir[:'@Gf(123)Lf'ZGf'aLfp*!**[p'ZGsp(13)+'Z(32)l*+G[p(26)-0]p0]po]

Try it online!

I'm enjoying learning Ly, so even though this is an old challenge I decided to give it a shot...

This is pretty brute force and the result isn't short compared to other entries. But it does show how to do things like if-then conditional blocks in Ly, so maybe someone will find it useful?

This bit reads in a line of input as codepoints, reverses the stack, then loops through each character/codepoint. At the end of the loop the character is printed, rot13'd or not.

ir[                                                            o]

The first thing to do is duplicate the character with : since we need to do two operations and it's easier to make a copy of the character on the stack now and then do the first one. That first test checks to see if the current character is in "a-z" or "A-Z". It does that by stacking the results from 4 comparisons, >=A >Z >=a and >z. Then it combines those 0|1 results mathematically to figure out if we're in the right range.

   :'@Gf(123)Lf'ZGf'aLfp*!**

Then the pattern I've found works for if-then is used to conditionally apply the rot-13 logic only when we get an alphabetic character. That pattern is ...test...[p...then-code...0]p. So in this case that's these bits.

                            [p                              0]p

And the code to apply the rotation starts by figuring out and remembering if the character is uppercase or not. After the s command, the backup cell will be 1|0 to indicated whether or not the character is uppercase.

                              'ZGsp

After that, the code adds 13 to the codepoint, then constructs what the max codepoint value is. It's either Z or z depending on the case of the original character. The l command pushed the backup cell (upper/lower flag) onto the stack so we use that to switch the Z to z if necessary.

                                   (13)+'Z(32)l*+

Once that max codepoint is on the stack the code conditionally subtracts 26 if the rotated number it too high.

                                                 G[p(26)-0]p

At that point, the character we want to print is on top of the stack.

GNU AWK, 147 8+82 = 90 bytes

-lordchr argument

BEGIN{RS=".|";ORS=e}$0=RT~/[A-Za-z]/?chr(ord(RT)+(ord(tolower(RT))>109?-13:13)):RT

Try it online!

After some thought, I realized it is possible to explore GNU AWK's ordchr extension to return the ASCII value of a character, saving tons of bytes. The ROT13 algorithm identifies if the letter is in the first or second half of the alphabet, adding of subtracting 13 to its ASCII value, accordingly.

This code transforms every character as Record Separator, then substitutes every $0 (formerly null) for the matching record separator (RT): ROT13 modified, if it's a letter; or itself, if not.

Vyxal, 10 bytes

kB½(nn13ǓĿ

Try it Online!

-4 thx to lyxal

Stax, 2 bytes

:3

Run and debug it

:3

Jelly, 12 bytes

ØAṙ13,µ;Œlyɠ

Try it online!

This takes input from STDIN

How it works

ØAṙ13,µ;Œlyɠ - Main link. Takes no arguments
ØA           - "ABC...XYZ"
  ṙ13        - Rotate 13 steps to the left
     ,       - Pair with the unaltered alphabet
      µ      - Begin a new link with ['NOP...KLM', 'ABC...XYZ'] as argument
        Œl   - Lowercase; ['nop...klm', 'abc..xyz']
       ;     - Concatenate; ['NOP...KLM', 'ABC...XYZ', 'nop...klm', 'abc..xyz']    
           ɠ - Read a line from STDIN
          y  - Transliterate

Google Sheets, 144

• Input: A1 (Given named range "A", +1 score)
• Column B: =ArrayFormula(CODE(MID(A,SEQUENCE(LEN(A)),1, given named range "B", +1 score
• Final output: =ArrayFormula(JOIN(,IF(B=0,,CHAR(IF((B>64)*(B<91),B+13*-1^(B>77),IF((B<97)+(B>122),B,B+13*-1^(B>109

x86-16 Machine Code, IBM PC DOS, 37 bytes

Binary:

00000000: b408 cd21 3c20 7e1c 8ad0 0c20 3c61 7c0e  ...!< ~.... <a|.
00000010: 3c7a 7f0a b60d 3c6e 7c02 b6f3 02d6 b402  <z....<n|.......
00000020: cd21 ebdc c3                             .!...

Build and test using xxd -r

Unassembled listing:

        START: 
B4 08       MOV  AH, 8          ; DOS API read char from STDIN (no echo) 
CD 21       INT  21H            ; read char into AL 
3C 20       CMP  AL, ' '        ; is any non-printable control char?
7E 1C       JL   EXIT           ; if so, end 
8A D0       MOV  DL, AL         ; save original char in DL 
0C 20       OR   AL, 'a'-'A'    ; lowercase the char 
3C 61       CMP  AL, 'a'        ; is char less than 'a'? 
7C 0E       JL   WRCHR          ; if so, do not convert 
3C 7A       CMP  AL, 'z'        ; is char greater than 'z'? 
7F 0A       JG   WRCHR          ; if so, do not convert 
B6 0D       MOV  DH, 'n'-'a'    ; add or subtract 13 
3C 6E       CMP  AL, 'n'        ; is char less than 'n'? 
7C 02       JL   ADD13          ; if so, add 13 
B6 F3       MOV  DH, 'a'-'n'    ; otherwise add -13 
        ADD13: 
02 D6       ADD  DL, DH         ; add 13 or -13
        WRCHR: 
B4 02       MOV  AH, 2          ; DOS API write char to STDOUT 
CD 21       INT  21H            ; write char in DL 
EB DC       JMP  START          ; keep looping 
        EXIT: 
C3           RET                ; return to DOS

As a standalone PC DOS executable program. Input is via STDIN, output to STDOUT.

Re-submitting answer to conform to STDIN challenge requirement.

naz, 176 bytes

2a2x1v6a8m2x2v9a4a2x3v9a5a2x4v5a2x5v9a4a2x6v9a5a2x7v1x1f1r3x1v7e3x5v5g3x2v2g8f0x1x2f3x4v3l8f0x1x3f3x3v4g9a4a8f0x1x4f9s4s8f0x1x5f3x7v6l8f0x1x6f3x6v4g9a4a8f0x1x7f0a0x1x8f1o1f0x1f

The most involved naz solution I've written so far. This program subtracts 13 from every letter in standard input that's greater than M, and adds 13 to every other letter - whether lowercase or uppercase.

It does use a lot of logic to determine what's a letter or not, so I wouldn't be surprised if this could be improved upon.

Works for any input string terminated with the control character STX (U+0002).

Explanation (with 0x commands removed)

2a2x1v                     # Set variable 1 equal to 2
6a8m2x2v                   # Set variable 2 equal to 64 ("@")
9a4a2x3v                   # Set variable 3 equal to 77 ("M")
9a5a2x4v                   # Set variable 4 equal to 91 ("[")
5a2x5v                     # Set variable 5 equal to 96 ("`")
9a4a2x6v                   # Set variable 6 equal to 109 ("m")
9a5a2x7v                   # Set variable 7 equal to 123 ("{")
1x1f                       # Function 1
    1r                     # Read a byte of input
      3x1v7e               # Jump to function 7 if it equals variable 1
            3x5v5g         # Jump to function 5 if it's greater than variable 5
                  3x2v2g   # Jump to function 2 if it's greater than variable 2
                        8f # Otherwise, jump to function 8
1x2f                       # Function 2
    3x4v3l                 # Jump to function 3 if the register is less than variable 4
          8f               # Otherwise, jump to function 8
1x3f                       # Function 3
    3x3v4g                 # Jump to function 4 if the register is greater than variable 3
          9a4a             # Otherwise, add 13 to the register,
              8f           # then jump to function 8
1x4f                       # Function 4
    9s4s8f                 # Subtract 13 from the register, then jump to function 8
1x5f                       # Function 5
    3x7v6l                 # Jump to function 6 if the register is less than variable 7
          8f               # Otherwise, jump to function 8
1x6f                       # Function 6
    3x6v4g                 # Jump to function 4 if the register is greater than variable 6
          9a4a             # Otherwise, add 13 to the register,
              8f           # then jump to function 8
1x7f                       # Function 7
    0a                     # Add 0 to the register
1x8f                       # Function 8
    1o1f                   # Output, then jump to function 1
1f                         # Call function 1

T-SQL, 80 bytes

The TRANSLATE function was introduced in SQL Server 2017.

Input is taken from the column I of the table T.

SELECT TRANSLATE(I,A+B,B+A)FROM(VALUES('ABCDEFGHIJKLM','NOPQRSTUVWXYZ'))V(A,B),T

SQL Fiddle

PHP - 27 Bytes

<?=str_rot13(fgets(STDIN));

LispLisp (16,636)

I'm sorry.

((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
  (lisp lisp))
 (((lisp (lisp (lisp (lisp lisp))))
   ((lisp (lisp (lisp lisp)))
    ((lisp (lisp (lisp (lisp lisp))))
     (((lisp (lisp (lisp (lisp lisp))))
       ((lisp (lisp (lisp lisp)))
        (((lisp (lisp (lisp (lisp lisp))))
          (((lisp (lisp (lisp (lisp lisp))))
            ((lisp (lisp (lisp lisp)))
             (lisp (lisp (lisp (lisp lisp))))))
           (((lisp (lisp (lisp (lisp lisp))))
             ((lisp (lisp (lisp lisp)))
              (lisp (lisp (lisp lisp)))))
            (((lisp (lisp (lisp (lisp lisp))))
              ((lisp (lisp (lisp lisp)))
               (lisp (lisp (lisp (lisp lisp))))))
             (((lisp (lisp (lisp (lisp lisp))))
               ((lisp (lisp (lisp lisp)))
                ((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))))
              (lisp (lisp (lisp lisp))))))))
         ((lisp (lisp (lisp lisp)))
          (lisp (lisp (lisp lisp)))))))
      (((lisp (lisp (lisp (lisp lisp))))
        ((lisp (lisp (lisp lisp)))
         (((lisp (lisp (lisp (lisp lisp))))
           (((lisp (lisp (lisp (lisp lisp))))
             ((lisp (lisp (lisp lisp)))
              (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
               ((lisp (lisp (lisp lisp)))
                (lisp (lisp (lisp lisp)))))))
            (((lisp (lisp (lisp (lisp lisp))))
              (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
               ((lisp (lisp (lisp lisp)))
                (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                 ((lisp (lisp (lisp lisp)))
                  ((lisp (lisp (lisp lisp))) (lisp lisp)))))))
             ((lisp (lisp (lisp lisp)))
              (((((lisp (lisp (lisp (lisp lisp))))
                  (((lisp (lisp (lisp (lisp lisp))))
                    ((lisp (lisp (lisp lisp)))
                     (lisp (lisp (lisp (lisp lisp))))))
                   (lisp (lisp (lisp lisp)))))
                 ((((lisp (lisp (lisp (lisp lisp))))
                    ((lisp (lisp (lisp (lisp lisp))))
                     (((lisp (lisp (lisp (lisp lisp))))
                       ((lisp (lisp (lisp lisp)))
                        (lisp (lisp (lisp (lisp lisp))))))
                      (lisp (lisp (lisp lisp))))))
                   (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                    (lisp lisp)))
                  (((lisp (lisp (lisp (lisp lisp))))
                    (((lisp (lisp (lisp (lisp lisp))))
                      ((lisp (lisp (lisp lisp)))
                       (lisp (lisp (lisp (lisp lisp))))))
                     (lisp (lisp (lisp lisp)))))
                   (lisp lisp))))
                (((lisp (lisp (lisp (lisp lisp))))
                  ((lisp (lisp (lisp lisp)))
                   ((lisp (lisp (lisp (lisp lisp))))
                    (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                     ((lisp (lisp (lisp lisp))) (lisp lisp))))))
                 (lisp (lisp (lisp lisp)))))
               ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                 (((lisp (lisp (lisp (lisp lisp))))
                   ((lisp (lisp (lisp lisp)))
                    ((((lisp (lisp (lisp (lisp lisp))))
                       (((lisp (lisp (lisp (lisp lisp))))
                         ((lisp (lisp (lisp lisp)))
                          (lisp (lisp (lisp (lisp lisp))))))
                        (lisp (lisp (lisp lisp)))))
                      (lisp lisp))
                     ((((lisp (lisp (lisp (lisp lisp))))
                        (((lisp (lisp (lisp (lisp lisp))))
                          ((lisp (lisp (lisp lisp)))
                           (lisp (lisp (lisp (lisp lisp))))))
                         (lisp (lisp (lisp lisp)))))
                       (((lisp (lisp (lisp (lisp lisp))))
                         (((lisp (lisp (lisp (lisp lisp))))
                           ((lisp (lisp (lisp lisp)))
                            (lisp (lisp (lisp (lisp lisp))))))
                          (lisp (lisp (lisp lisp)))))
                        (lisp lisp)))
                      (((lisp (lisp (lisp (lisp lisp))))
                        ((lisp (lisp (lisp lisp)))
                         ((lisp (lisp (lisp (lisp lisp))))
                          (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                           ((lisp (lisp (lisp lisp))) (lisp lisp))))))
                       (lisp (lisp (lisp lisp))))))))
                  (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                   ((lisp (lisp (lisp lisp)))
                    ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                      (lisp lisp))
                     (((lisp (lisp (lisp (lisp lisp))))
                       ((lisp (lisp (lisp lisp)))
                        (((lisp (lisp (lisp (lisp lisp))))
                          ((lisp (lisp (lisp lisp)))
                           ((lisp (lisp (lisp (lisp lisp))))
                            (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                             ((lisp (lisp (lisp lisp))) (lisp lisp))))))
                         (lisp (lisp (lisp lisp))))))
                      (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                       (lisp lisp))))))))
                (((lisp (lisp (lisp (lisp lisp))))
                  ((lisp (lisp (lisp lisp)))
                   ((((lisp (lisp (lisp (lisp lisp))))
                      (((lisp (lisp (lisp (lisp lisp))))
                        ((lisp (lisp (lisp lisp)))
                         (lisp (lisp (lisp (lisp lisp))))))
                       (lisp (lisp (lisp lisp)))))
                     (((lisp (lisp (lisp (lisp lisp))))
                       ((lisp (lisp (lisp lisp)))
                        (((lisp (lisp (lisp (lisp lisp))))
                          (((lisp (lisp (lisp (lisp lisp))))
                            ((lisp (lisp (lisp lisp)))
                             (lisp (lisp (lisp (lisp lisp))))))
                           (lisp (lisp (lisp lisp)))))
                         (((lisp (lisp (lisp (lisp lisp))))
                           (((lisp (lisp (lisp (lisp lisp))))
                             ((lisp (lisp (lisp lisp)))
                              (lisp (lisp (lisp (lisp lisp))))))
                            (lisp (lisp (lisp lisp)))))
                          (lisp lisp)))))
                      ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                        (lisp lisp))
                       (((lisp (lisp (lisp (lisp lisp))))
                         (((lisp (lisp (lisp (lisp lisp))))
                           ((lisp (lisp (lisp lisp)))
                            (lisp (lisp (lisp (lisp lisp))))))
                          (lisp (lisp (lisp lisp)))))
                        (lisp lisp)))))
                    (((lisp (lisp (lisp (lisp lisp))))
                      ((lisp (lisp (lisp lisp)))
                       ((lisp (lisp (lisp (lisp lisp))))
                        (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                         ((lisp (lisp (lisp lisp)))
                          ((((lisp (lisp (lisp (lisp lisp))))
                             (((lisp (lisp (lisp (lisp lisp))))
                               ((lisp (lisp (lisp lisp)))
                                (lisp (lisp (lisp (lisp lisp))))))
                              (lisp (lisp (lisp lisp)))))
                            (((lisp (lisp (lisp (lisp lisp))))
                              ((lisp (lisp (lisp lisp)))
                               (((lisp (lisp (lisp (lisp lisp))))
                                 (((lisp (lisp (lisp (lisp lisp))))
                                   ((lisp (lisp (lisp lisp)))
                                    (lisp (lisp (lisp (lisp lisp))))))
                                  (lisp (lisp (lisp lisp)))))
                                (((lisp (lisp (lisp (lisp lisp))))
                                  (((lisp (lisp (lisp (lisp lisp))))
                                    ((lisp (lisp (lisp lisp)))
                                     (lisp (lisp (lisp (lisp lisp))))))
                                   (lisp (lisp (lisp lisp)))))
                                 (lisp lisp)))))
                             ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                               (lisp lisp))
                              (((lisp (lisp (lisp (lisp lisp))))
                                (((lisp (lisp (lisp (lisp lisp))))
                                  ((lisp (lisp (lisp lisp)))
                                   (lisp (lisp (lisp (lisp lisp))))))
                                 (lisp (lisp (lisp lisp)))))
                               (lisp lisp)))))
                           ((lisp (lisp (lisp (lisp lisp))))
                            (((lisp (lisp (lisp (lisp lisp))))
                              ((lisp (lisp (lisp lisp)))
                               (lisp (lisp (lisp (lisp lisp))))))
                             (lisp (lisp (lisp lisp)))))))))))
                     (lisp (lisp (lisp lisp)))))))
                 ((((lisp (lisp (lisp (lisp lisp))))
                    (((lisp (lisp (lisp (lisp lisp))))
                      ((lisp (lisp (lisp lisp)))
                       (lisp (lisp (lisp (lisp lisp))))))
                     (lisp (lisp (lisp lisp)))))
                   (((lisp (lisp (lisp (lisp lisp))))
                     ((lisp (lisp (lisp lisp)))
                      (((lisp (lisp (lisp (lisp lisp))))
                        (((lisp (lisp (lisp (lisp lisp))))
                          ((lisp (lisp (lisp lisp)))
                           (lisp (lisp (lisp (lisp lisp))))))
                         (lisp (lisp (lisp lisp)))))
                       (((lisp (lisp (lisp (lisp lisp))))
                         (((lisp (lisp (lisp (lisp lisp))))
                           ((lisp (lisp (lisp lisp)))
                            (lisp (lisp (lisp (lisp lisp))))))
                          (lisp (lisp (lisp lisp)))))
                        (lisp lisp)))))
                    ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                      (lisp lisp))
                     (((lisp (lisp (lisp (lisp lisp))))
                       (((lisp (lisp (lisp (lisp lisp))))
                         ((lisp (lisp (lisp lisp)))
                          (lisp (lisp (lisp (lisp lisp))))))
                        (lisp (lisp (lisp lisp)))))
                      (lisp lisp)))))
                  (((lisp (lisp (lisp (lisp lisp))))
                    ((lisp (lisp (lisp lisp)))
                     ((lisp (lisp (lisp (lisp lisp))))
                      (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                       ((lisp (lisp (lisp lisp)))
                        (((lisp (lisp (lisp (lisp lisp))))
                          ((lisp (lisp (lisp lisp)))
                           (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                            ((lisp (lisp (lisp lisp)))
                             (lisp (lisp (lisp lisp)))))))
                         (((lisp (lisp (lisp (lisp lisp))))
                           (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                            ((lisp (lisp (lisp lisp)))
                             (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                              ((lisp (lisp (lisp lisp)))
                               ((lisp (lisp (lisp lisp))) (lisp lisp)))))))
                          ((lisp (lisp (lisp lisp)))
                           (((((lisp (lisp (lisp (lisp lisp))))
                               (((lisp (lisp (lisp (lisp lisp))))
                                 ((lisp (lisp (lisp lisp)))
                                  (lisp (lisp (lisp (lisp lisp))))))
                                (lisp (lisp (lisp lisp)))))
                              (((lisp (lisp (lisp (lisp lisp))))
                                ((lisp (lisp (lisp lisp)))
                                 (((lisp (lisp (lisp (lisp lisp))))
                                   (((lisp (lisp (lisp (lisp lisp))))
                                     ((lisp (lisp (lisp lisp)))
                                      (lisp (lisp (lisp (lisp lisp))))))
                                    (lisp (lisp (lisp lisp)))))
                                  (((lisp (lisp (lisp (lisp lisp))))
                                    (((lisp (lisp (lisp (lisp lisp))))
                                      ((lisp (lisp (lisp lisp)))
                                       (lisp (lisp (lisp (lisp lisp))))))
                                     (lisp (lisp (lisp lisp)))))
                                   (lisp lisp)))))
                               ((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                                 (lisp lisp))
                                (((lisp (lisp (lisp (lisp lisp))))
                                  (((lisp (lisp (lisp (lisp lisp))))
                                    ((lisp (lisp (lisp lisp)))
                                     (lisp (lisp (lisp (lisp lisp))))))
                                   (lisp (lisp (lisp lisp)))))
                                 (lisp lisp)))))
                             (((lisp (lisp (lisp (lisp lisp))))
                               ((lisp (lisp (lisp lisp)))
                                ((lisp (lisp (lisp (lisp lisp))))
                                 (((lisp (lisp (lisp (lisp lisp))))
                                   (lisp lisp))
                                  ((lisp (lisp (lisp lisp))) (lisp lisp))))))
                              (lisp (lisp (lisp lisp)))))
                            (((((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
                               (lisp lisp))
                              (((lisp (lisp (lisp (lisp lisp))))
                                ((lisp (lisp (lisp lisp)))
                                 ((lisp (lisp (lisp (lisp lisp))))
                                  (((lisp (lisp (lisp (lisp lisp))))
                                    ((lisp (lisp (lisp lisp)))
                                     (lisp (lisp (lisp (lisp lisp))))))
                                   (((lisp (lisp (lisp (lisp lisp))))
                                     ((lisp (lisp (lisp lisp)))
                                      ((lisp (lisp (lisp (lisp lisp))))
                                       (lisp lisp))))
                                    (lisp (lisp (lisp lisp))))))))
                               (((lisp (lisp (lisp (lisp lisp))))
                                 ((lisp (lisp (lisp lisp)))
                                  ((lisp (lisp (lisp (lisp lisp))))
                                   ((lisp (lisp (lisp lisp)))
                                    (lisp (lisp (lisp lisp)))))))
                                (((lisp (lisp (lisp (lisp lisp))))
                                  (((lisp (lisp (lisp (lisp lisp))))
                                    ((lisp (lisp (lisp lisp)))
                                     (lisp (lisp (lisp (lisp lisp))))))
                                   (((lisp (lisp (lisp (lisp lisp))))
                                     ((lisp (lisp (lisp lisp)))
                                      (lisp (lisp (lisp lisp)))))
                                    (((lisp (lisp (lisp (lisp lisp))))
                                      (lisp lisp))
                                     (lisp lisp)))))
                                 ((lisp (lisp (lisp lisp)))
                                  ((lisp (lisp (lisp (lisp lisp))))
                                   (((lisp (lisp (lisp (lisp lisp))))
                                     ((lisp (lisp (lisp lisp)))
                                      (lisp (lisp (lisp (lisp lisp))))))
                                    (lisp (lisp (lisp lisp))))))))))
                             ((lisp (lisp (lisp lisp))) (lisp lisp))))))))))))
                   (lisp (lisp (lisp lisp))))))))))))
          (lisp lisp))))
       (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
        ((lisp (lisp (lisp lisp)))
         (lisp (lisp (lisp lisp))))))))))
  (((lisp (lisp (lisp (lisp lisp))))
    (((lisp (lisp (lisp (lisp lisp))))
      ((lisp (lisp (lisp lisp)))
       (lisp (lisp (lisp (lisp lisp))))))
     (((lisp (lisp (lisp (lisp lisp))))
       ((lisp (lisp (lisp lisp)))
        (lisp (lisp (lisp lisp)))))
      (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
       (lisp lisp)))))
   ((lisp (lisp (lisp lisp)))
    (((lisp (lisp (lisp (lisp lisp)))) (lisp lisp))
     ((lisp (lisp (lisp lisp)))
      ((lisp (lisp (lisp lisp))) (lisp lisp))))))))

Japt, 28 bytes

c_d)è"%l")?Z|H)<#n?Z+D:Z-D:Z

Try it!

c_d)è"%l")?Z|H)<#n?Z+D:Z-D:Z
c_                                # map input string through a function
  d)è"%l")?                       # regex check if current character is a letter
           Z|H)<#n?               # is it less than the letter n?
                   Z+D:           # if yes, then add 13
                       Z-D:       # otherwise, subtract 13
                           Z      # not a letter, do not transform

Python 3, 70 bytes

a=input()
for i in a:print(end=i.isalpha()*chr(65+(ord(i)-52)%26)or i)

Julia 1.0, 69 bytes

(x->(c=Char(x);print(c+isletter(c)*13*(-1)^(x&31>13)))).(read(stdin))

Try it online!

Explanation

Most of the code is an anonymous function that takes an integer codepoint and prints the corresponding ROT-13'd character:

x->(c=Char(x);print(c+isletter(c)*13*(-1)^(x&31>13)))

x->(                                                )  # Anonymous function of x
    c=Char(x);                                         # Cast x to Char and save as c
                    c+                                 # Start with c and add to its codepoint:
                      isletter(c)*                     # If c is not a letter, the rest of this is
                                                       # multiplied by 0
                                  13*(-1)^(       )    # 13, times +/- 1 according to:
                                           x&31>13     # Low 5 bits of x are greater than 13
                                                       # I.e. x > 'M' (if x is uppercase) or x > 'm'
                                                       # (if x is lowercase)
              print(                               )   # Output the resulting character

We then apply this function, vectorized, to the array of (integer) codepoints returned by read(stdin).

Powershell, 77 bytes

-join($args|% t*y|%{[char]((("$_"-match'[a-m]')-("$_"-match'[n-z]'))*13+$_)})

Test script:

$f = {

-join($args|% t*y|%{[char]((("$_"-match'[a-m]')-("$_"-match'[n-z]'))*13+$_)})

}

@(

,("Hello!","Uryyb!")
,("HELLO","URYYB")
,("URYYB","HELLO")
,("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz","NOPQRSTUVWXYZABCDEFGHIJKLMnopqrstuvwxyzabcdefghijklm")
,("Why did the chicken cross the road?
Gb trg gb gur bgure fvqr!",
"Jul qvq gur puvpxra pebff gur ebnq?
To get to the other side!")

) | % {
    $s,$expected = $_
    $result = &$f $s
    "$($result-eq$expected): $result"
}

Output:

True: Uryyb!
True: URYYB
True: HELLO
True: NOPQRSTUVWXYZABCDEFGHIJKLMnopqrstuvwxyzabcdefghijklm
True: Jul qvq gur puvpxra pebff gur ebnq?
To get to the other side!

Retina, 13 bytes

13+T`zlZL`l_L

Try it online!

The straightforward transliteration that directly applies ROT13 would be 2 bytes longer Try it online!

Explanation

The transliteration stage here is wrapped in a loop stage making it run 13 times (or until the string is not transformed anymore, which can only happen if the input string has no alphabetic characters).

In the transliteration, characters in zlZL are transformed into the characters at the same positions in l_L. Here, z and Z are exactly what they look like, while l and L get converted into the lowercase and uppercase alphabets. The final letters of those alphabets are ignored because they already appear earlier in the string, and _ is just a placeholder to make the uppercase alphabet line up correctly. The result is transforming each letter into the next one (a->b,b->c,...,z->a); doing this 13 times is ROT13.

05AB1E, 13 12 bytes

Saved a byte thanks to robbie0630

ADu)øJD2äRJ‡

Try it online!

Explanation

ADu           # push lower-case and uppercase alphabet
   )øJ        # zip, flatten and join, producing aAbB..zZ
      D2äRJ   # split a copy in 2 pieces, reverse and join producing nNoO..mM
           ‡  # translate input by replacing members of the alphabet 
              # with the corresponding member of the rot-13 alphabet
              # implicitly display

J, 32 29 bytes

a.{~3&u:+13*2|&.>:'@MZ`mz'&I.

Try it online!

Bash, 23 bytes

Canonical 23-character answer:

tr A-Za-z N-ZA-Mn-za-m

Befunge-93, 72 67 bytes

Edit: -5 bytes thanks to James Holderness

<,<v!:+*"a"*`"`"\`\"{":\*"G"*`"@"\`\"[":::_@#+1:~
+0|_\"N"%6-55*1+%

Try it online!

Kinda disappointed in the previous Befunge answers, so I wrote one with much less whitespace.

C#, 94 bytes

s=>{var r="";foreach(var c in s)r+=(char)(Char.IsLetter(c)?(c|32)<110?c+13:c-13:c);return r;};

Anonymous function which returns the string of characters rotated by 13 places, based on this C answer from Fors. Works for any lower or upper letters while keeping other input the same.

Full program with ungolfed method and test cases:

using System;

namespace ROT13
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<string, string> f =
            s =>
            {
                var r = "";
                foreach (var c in s)
                    r += (char)(Char.IsLetter(c) ? (c | 32) < 110 ? c + 13 : c - 13 : c);
                return r;
            };

            Console.WriteLine(f("TOO MANY SECRETS!"));   // GBB ZNAL FRPERGF!
            Console.WriteLine(f("too many secrets!"));   // gbb znal frpergf!
            Console.WriteLine(f("gbb znal frpergf!"));   // too many secrets!
            Console.WriteLine(f("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890,./"));
// NOPQRSTUVWXYZABCDEFGHIJKLMnopqrstuvwxyzabcdefghijklm1234567890,./
        }
    }
}

Python 2, 34 bytes

print raw_input().encode('rot13')

Jolf, noncompeting (language postdates challenge)

Jolf, 3 bytes

Try it here!

,Ri
,R  rot13
  i the input

Or, with new implicit input, ,R.

I'm sorry, but I'm not. I implemented this because it appears often in code-breaking puzzles, which I use Jolf a lot for, and recently used in an ARG. \o/

A longer one (try that one here):

ρi"[%]"γpWpud.pWp2pu+t3 iγH
ρi                           regex replace input
  "[%]"                      "[...]" following
        pWpu                 "abc...xyzABC....XYZ"
       γ                     γ = that
            d                functional replace
             .         _iγH  the index on the alphabet that the element is
                p2pu         shift uppercase alphabet
                    +t3      over thirteen
              pW             upper + lower of that

Python: 60 bytes

lambda s:''.join([chr((ord(c.lower())-84)%26+97)for c in s])

The only thing I don't like is having that .lower() in there. Any suggestions?

edit: I can get rid of the .lower(), and handle capitals better, but it's 94 bytes now:

lambda s:''.join([chr((ord(c)-(52if ord(c)<97else 84))%26+(65if ord(c)<97else 97))for c in s])

R, 37 bytes

example("chartr");cat(rot(scan(,"")))

example("chartr") runs the examples for chartr, which includes the rot function, which is ROT13 by default....

pyg-i - 76 Bytes

P(STDI.read().t({a:a-13 if(77<a<91)or a>109 else a+13 for a in M(ord,STl)}))

Python Equivient:

import sys,string
print(sys.stdin.read().translate({a:a-13 if(77<a<91)or a>109 else a+13 for a in map(ord,string.ascii_letters)}))

C, 136 bytes

I have never felt like any of my solutions are good enough to post on here, but made this for fun, and figured that it will be my gateway drug into code golf.

#define z(x) c>=x&&c<x+13
#define q(w) c>=w&&c<w+13
main(c){for(;(c=getchar())>=0;putchar(z('A')||z('a')?c+13:q('M')||q('m')?c-13:c));}

Befunge - 7x30 = 210 6x26 = 156 characters

New streaming version that supports both upper and lower case and should support unlimited input.

v,<               <<     <
  ^-4-9<    >:"A"\`|
     >:"a"\`|     #>:"Z"`|
>~:0`| #    >:"z"`|
,    @ |    <`"m":<v`"M":<
^  +4+9<    ^      <

The old version

This stores the values inside its own source code. Really shows off how horrible it is to try and output stored values in the same order that you receive them. Only supports lowercase characters.

vp0p11:+1g11<      < <
v                    ^-4-9<
v    >:"a"\`|>:"z"`|>:"m"`|
>~:0`|      >^     >^#
                     ^+4+9<
     >$011g1+0p>12g1+:12p0g:v
               ^           ,_@

I'm not sure exactly what limitations this has, using http://www.quirkster.com/iano/js/befunge.html as the interpreter it does appear to break with large inputs.

vim, 5 keystrokes

Assuming normal mode and that the text is already written in the buffer:

ggg?G

Or, fallowing vimgolf's conventions:

g?GZZ

You can also invoke it as a terminal command, something like this:

$ vim -c 'norm g?G' -
< your text here ...
... multiple lines if you want ...
... terminate input with ctrl+D on a blank line >

I guess the latter would count as a "program" of 8 characters (norm g?G)

Scala (96 chars)

def r(s:String)=s.map{c⇒val m = if(c<91)65 else 97
if(c.isLetter)
((c+13-m)%26+m).toChar
else c}

Haskell (103)

Reused maybe c id $ lookup c from jloy's answer.

main=interact$map(\c->maybe c id$lookup c$[['a'..'z'],['A'..'Z']]>>=zip<*>uncurry(flip(++)).splitAt 13)

JavaScript 135

s=prompt(),o='',i=0
while((c=s.charCodeAt(i++)))c+=c>64&&c<91?c<52?13:-13:c>96&&c<123?c<109?13:-13:0,o+=String.fromCharCode(c)
alert(o)

Javascript (165)

a=prompt();y="ABCDEFGHIJKLMNOPQRSTUVWXYZ";b=y[s="substr"](13)+y[s](0,13);y+=y[l="toLowerCase"]();b+=b[l]();o='';for(i=0;a[i];i++)o+=b[y.indexOf(a[i])]||a[i];alert(o)

or (167) as previous Javascript solution, assuming readLine and print:

a=readLine();y="ABCDEFGHIJKLMNOPQRSTUVWXYZ";b=y[s="substr"](13)+y[s](0,13);y+=y[l="toLowerCase"]();b+=b[l]();o='';for(i=0;a[i];i++)o+=b[y.indexOf(a[i])]||a[i];print(o)

CHIQRSX9+, 1

R

You just have to use the right tool for the problem.
CHIQRSX9+ is Turing complete, and it can read and write from standard channels with C.

Tcl, 74 chars

package require [set c tcl::transform::rot];$c 13 stdin;fcopy stdin stdout

K, 31

{x^(,/{x!(13_x),13#x}'.Q`A`a)x}

C: 69 68 characters

Alright, I know this thread is long dead, but I couldn't stand the (long) C-solution which doesn't even compile on Clang (but does on GCC).

main(c){putchar(isalpha(c=getchar())*((c|32)<110?13:-13)+c);main();}

It is probably almost still squeezable. It certainly was squeezable. And not only was it squeezable, it was possible to make it recursive.

Mathematica 102

StringReplace[Input[],
Join@@Table[Rule@@FromCharacterCode/@{i+c,Mod[i+13,26]+c},{c,{65,97}},{i,0,25}]]

JavaScript 1.8, 106

alert(prompt().replace(/\w/g,function(c)String.fromCharCode(c.charCodeAt()+(c.toLowerCase()<'n'?13:-13))))

JavaScript, 115

alert(prompt().replace(/\w/g,function(c){return String.fromCharCode(c.charCodeAt()+(c.toLowerCase()<'n'?13:-13))}))

This solution solves the problem by adding 13 to the character code if the character in question is in the first half of the alphabet, or subtracting 13 if it's in the second half.

Scala 108

def m(a:Int,z:Int,c:Int)=if(c>=a&&c<z)a+((c-a+13)%26)else c
"Ok?".map(c=>print(m(65,91,m(97,123,c)).toChar))

ungolfed:

def m (a: Int, z:Int, c:Int) = if (c >= a && c <= z) a+((c-a+13)%26) else c
"Ok?".foreach (c => print (m ('A', 'Z', m ('a', 'z', c)).toChar))

result:

Bx?

Haskell, 100 characters

a%b=([a..b]++)
main=interact$map$toEnum.((0%64$78%90$65%77$91%96$110%122$97%109$[123..])!!).fromEnum

Python 3 (107)

Ok, I promise to stop answering this question now, but I felt compelled to beat the DC answer in Python. This probably reflects poorly on me as a person :).

import sys;[print(x.isalpha()and chr((ord(x)&96)+1+(ord(x)%32+12)%26)or x,end='')for x in sys.stdin.read()]

Java 251 chars

public class r{public static void main(String[] a){String s = a[0];for(int i=0;i<s.length();){char c=s.charAt(i++);if(c>='a'&&c<='m')c+=13;else if(c>='n'&&c<='z')c-= 13;else if(c>='A'&&c<='M')c+=13;else if(c>='A'&&c <='Z')c-=13;System.out.print(c);}}}

Haskell - 112 characters

r l=drop 13 l++take 13 l
t=['a'..'z']
s=['A'..'Z']
main=interact$map(\x->maybe x id$lookup x$zip(t++s)$r t++r s)

Delphi, 110

var c:Char;begin repeat Read(c);Write(Chr(Ord(c)+(Ord(c in['A'..'M'])-Ord(c in['N'..'Z']))*13));until EOF;end.

tr/// solution in Perl (39 characters), boilerplate can be removed with -p:

while(<>){y/a-zA-Z/n-za-mN-ZA-M/;print}

Using -p (23 characters including the extra switch):

perl -pe'y/a-zA-Z/n-za-mN-ZA-M/'

PHP - 103 98 80 characters

(not using str_rot13())

<?=preg_replace('#[a-zA-Z]#e','chr(($x=ord("\0"))-$x%32+1+($x%32+12)%26)',`cat`);

PHP - 41 Characters

while($r=fgets(STDIN))echo str_rot13($r);

Ruby - 60 57 38 37 chars

Edit: And just realised Ruby strings have a tr method.

puts$<.read.tr'A-Za-z','N-ZA-Mn-za-m'

Test

input = "The challenge: To read an input of arbitrary length and produce the ROT13 of the input. All characters besides A-Z should be copied to the output verbatim, and case should be preserved if possible.

Any language that can read and write standard streams is fair game."

output = `echo '#{input}' | ruby golf-rot13.rb`

puts "Input:"
puts input
puts "-------"
puts "Output:"
puts output

Gives:

Input:
The challenge: To read an input of arbitrary length and produce the ROT13 of the input. All characters besides A-Z should be copied to the output verbatim, and case should be preserved if possible.

Any language that can read and write standard streams is fair game.
-------
Output:
Gur punyyratr: Gb ernq na vachg bs neovgenel yratgu naq cebqhpr gur EBG13 bs gur vachg. Nyy punenpgref orfvqrf N-M fubhyq or pbcvrq gb gur bhgchg ireongvz, naq pnfr fubhyq or cerfreirq vs cbffvoyr.

Nal ynathntr gung pna ernq naq jevgr fgnaqneq fgernzf vf snve tnzr.

Perl6 (54)

$*IN.lines».trans("a..zA..Z"=>"n..za..mN..ZA..M").say

Bash - 5 chars

rot13

Python (117 bytes)

Here's a Python version that avoids the rot13()-method.

import sys
print"".join([chr(x/32*32+1+(x%32+12)%26if 64<x<91or 96<x<123 else x)for x in map(ord,sys.stdin.read())])

C - 83 79 characters

main(c,b){while((c=getchar())>=0)b=c&96,putchar(isalpha(c)?b+1+(c-b+12)%26:c);}

Readable version:

#include <ctype.h>
#include <stdio.h>

int main(void)
{
    int c, base;

    while ((c = getchar()) >= 0) {
        if (isalpha(c)) {
            base = (c & 96) + 1; /* First letter of the upper or lower case. */
            c = base + (c - base + 13) % 26;
        }
        putchar(c);
    }

    return 0;
}

DC (111 108 for the dc itself)

Ok, here it is in (mostly) dc and some sed and od magic to get it into the right format for the code. If you don't count the input thing (echo -n MESSAGE |) it's 160 bytes:

od -An -t dC|sed 's/^\ *//;s/\ \{2,3\}/\n/g'|dc -e'[13+26%]sm[65-lmx65+]su[97-lmx97+]sl[96<b64<dPc]sa[91>c]sd[123>e]sb[lux]sc[llxdd]se[ddddlaxlrx]sy[?z0<y]dsrx'

As a point of interest, the dc programme itself is only a 108 bytes long, shorter than the non-library python version. It even preserves case and punctuation, and beats Javascript in the above submission! If only I could better parse the output of od, or better yet replace it altogether.

EDIT: It's worth noting that the question doesn't indicate a trailing new line 10P which saves me three further bytes.

EDIT 2: There's no specification for the format of the input, so I assume it's taken in as is convenient for my programme :P