J, 5 bytes

Assumes the input string is in variable b.

b='0'

This does not do what it would do in most languages...

The J comparison operator is just = (=: and =. are global and local assignment, respectively). However, = doesn't work like the normal == operator: it compares item-by-item. Keep in mind that an array is formed like this: 0 2 3 2 3 1 2 3 4. 2 = 0 2 3 2 3 1 2 3 4 gives 0 1 0 1 0 0 1 0 0 for example. This is similar for a string: 'a'='abcadcadda' doesn't just return 0, it returns 1 0 0 1 0 0 1 0 0 1 (This can be extrapolated to mean 0 with */, which basically means all.) In this case however, this behavior is excelent, since we want a string of ones and zeros, or true's and false's. Since J's bools are 1 and 0, this results in an array of 1's and 0's (They aren't strings, and every other character other than 1 would also result in 0 in this array.) This doesn't need printing: J automatically prints the result of an expression. I hope this was adequate explanation, if not, please ask for something that isn't yet clear in the comments. This answer also could've been '0'&= (or =&'0'), but I felt that b='0' was clearer.

GolfScript, 5 bytes

{1^}%

Try it online.

How it works

• GolfScript reads the entire input from STDIN and places it on the stack as a string.

• {}% goes through all characters in the string and executes the code block for all of them.

• 1^ computes the exclusive OR of the characters ASCII code with 1. “0” corresponds to the ASCII code 48, “1” to ASCII code 49.

  Since 48 ^ 1 = 49 and 49 ^ 1 = 48, this turns 0's into 1's and 1's into 0's.

• Once finished, GolfScript prints the modified string.

CJam - 4

q1f^

This xor's every character with 1.
Unlike the other CJam answer, I'm not assuming the input is already on the stack.

Try it at http://cjam.aditsu.net/

Bash+coreutils, 8 bytes

tr 01 10

Takes input from STDIN.

Or

sed, 8 bytes

y/01/10/

x86 machine code on DOS - 14 bytes

I think it doesn't get much shorter than this.

00000000  b4 08 cd 21 34 01 88 c2  b4 02 cd 21 eb f2        |...!4......!..|

This version features advanced interactivity™ - after running it from the command line, it spits out the "inverted" characters as long as you write the input digits (which are not echoed); to exit, just do a Ctrl-C.

Unlike the previous solution, this has some trouble running in DosBox - since DosBox doesn't support Ctrl-C correctly, you are forced to close the DosBox window if you want to exit. In a VM with DOS 6.0, instead, it runs as intended.

NASM source:

org 100h

section .text

start:
    mov ah,8
    int 21h
    xor al,1
    mov dl,al
    mov ah,2
    int 21h
    jmp start

Old solution - 27 25 22 bytes

This accepted its input from the command line; runs smoothly as a .COM file in DosBox.

00000000  bb 01 00 b4 02 8a 97 81  00 80 f2 01 cd 21 43 3a  |.............!C:|
00000010  1e 80 00 7c f0 c3                                 |...|..|

NASM input:

    org 100h

section .text

start:
    mov bx, 1
    mov ah, 2
loop:
    mov dl, byte[bx+81h]
    xor dl, 1
    int 21h
    inc bx
    cmp bl, byte[80h]
    jl loop
exit:
    ret

CJam, 4 bytes

:~:!

Assumes the original string is already on the stack. Prints the modified string.

Try it online by pasting the following Code:

"10101110101010010100010001010110101001010":~:!

How it works

• :~ evaluates each character of the string, i.e., it replaces the character 0 with the integer 0.

• :! computes the logical NOT of each integer. This turns 0's into 1's and 1's into 0's.

Brainfuck (70 71)

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

Explanation:

>,[>,]                       Read characters until there are none left.
<[<]                         Return to start
>[<                          Loop as long as there are characters to invert
  +++++++[>-------<-]        Subtract 49 (ASCII value of 1)
  >[++<]                     If not 0, add 2
  +++[<++++>-]<[>>++++<<-]>> Add 48
  .                          Print
  [-]                        Set current cell to 0
>]                           Loop

PHP - 19 bytes

<?=strtr($s,[1,0]);

Yea, not really original, I guess!

C: 29

i(char*s){*s^=*s?i(s+1),1:0;}

Try it online here.

Thanks for pointing out the XOR trick, Dennis.

Python 2.7 – 34*

Oh how much this first one sucks. Pretty ugly, this one is. 63 chars.

print''.join([bin(~0)[3:] if x == '0' else bin(~1)[4:] for x in ''])

This one is a bit better but still not that fancy. 44 chars.

print''.join([str(int(not(int(x)))) for x in ''])

Since int(x) and 1 returns int(x) if it's not 0 and otherwise False. The solution can be further reduced to 36 chars.

print''.join([str(1-int(x)) for x in ''])

Since join() takes a generator the brackets can be removed. 32 chars.

print''.join(str(1-int(x))for x in'')

And backticks can be used instead of str()

print''.join(`1-int(x)`for x in'')

Reduced to 44 from 34 thanks to pointers from @TheRare

Finding one's complement is difficult in python since bin(-int) returns -0bxxx hence the above.

Pancake Stack, 532 bytes

Put this tasty pancake on top!
[]
Put this delicious pancake on top!
[#]
Put this  pancake on top!
How about a hotcake?
If the pancake is tasty, go over to "#".
Eat all of the pancakes!
Put this supercalifragilisticexpialidociouseventhoughtheso pancake on top!
Flip the pancakes on top!
Take from the top pancakes!
Flip the pancakes on top!
Take from the top pancakes!
Put this supercalifragilisticexpialidociouseventhoughthes pancake on top!
Put the top pancakes together!
Show me a pancake!
If the pancake is tasty, go over to "".

It assumes the input is terminated by a null character. The strategy is as follows:

• Take a character of input
• Subtract the ascii value of 1 from it.
• Subtract that from 0 (yielding a 1 if we had 0, or a 0 if we had 1)
• Add the ascii value of 0 to it
• Print the char.
• Repeat

Javascript (ES6) 36

alert(prompt().replace(/./g,x=>x^1))

Labyrinth, 6 bytes

(Labyrinth is newer than this challenge, so this answer doesn't compete - not that it's winning anyway...)

1,
.$@

This code assumes that STDIN contains only the digits (in particular, no trailing newline).

The instruction pointer (IP) starts in the top left corner going right. While there are digits to read it will cycle in a tight loop through the left-hand 2x2 block: 1 push a 1, , read a digit, $ XOR it with 1 to toggle the last bit, . print the result. The IP takes this loop because the top of the stack is positive after the XOR, such that it will take a right-turn. When we hit EOF, , returns -1 instead. Then the XOR will yield -2 and with this negative value the IP takes a left-turn onto the @ and the program ends.

This solution should be optimal for Labyrinth: you need , and . for an I/O loop and @ to terminate the program. You need at least two characters (here 1 and $) to toggle the last bit. And you need at least one newline for a loop which can be terminated.

Unless... if we ignore STDERR, i.e. allow terminating with an error we can save the @ and we also don't need any way to switch between two paths. We just keep reading and printing until we accidentally try to print a negative value (the -2). This allows for at least two 5-byte solutions:

1,
.$

,_1$.

Perl, 9 characters

'y/10/01/'

The 9th character is the 'p' flag

Usage:

$ echo '10101001' | perl -pe 'y/10/01/'

Python 2.x - 44 bytes

print''.join(`1-int(x)`for x in raw_input())

Why make it complex, or use some cheaty variables?

PHP > 5.4 -- 37 characters

foreach(str_split($s) as $v)echo 1^$v

$s is the input

Try it online

TI-BASIC, 7 bytes

This is a function that takes a binary string (through Ans) as input and returns the output as an inverted (not reversed) string, as specified. For more help, you can read through list application by not( on the TI-BASIC wiki. I'm using the compiled version because it is smaller:

»*r>Õ¸r

In hex:

BB 2A 72 3E D5 B8 72

Explanation

»*r - Take function input as string and convert to list

> - Pipe given list to the next operators

Õ¸r - Return the inverse of the list

Haskell, 22 bytes

map(\c->"10"!!read[c])

I was surprised by the lack of Haskell solutions to this challenge, so here's one. It evaluates to a function that takes a string and returns its inverse.

Explanation

Nothing fancy here.

map(\c->             )  -- For each character c in the input string:
                  [c]   -- wrap c into a string,
              read      -- convert to integer,
        "10"!!          -- and index the string "10" with it.

Turing Machine Code, 32 bytes (1 state - 3 colors)

Using the rule table syntax required by this online TM simulator. Borrowed from a post I made to my Googology Wiki user blog a few months back.

0 0 1 r *
0 1 0 r *
0 _ _ * halt

You may also test this using this java implementation.

Python3, 39

Methinks Python is not the best language for this. :)

for i in input():print(1-int(i),end='')

If you care about having a newline after the output, here's a 43-character alternative:

print(''.join("01"[i<"1"]for i in input()))

Ruby: 23

p $<.read.tr("01","10")

J - 11 chars

Boolean values in J are represented as the integers 0 and 1, which of course are also valid indices into arrays (in this case, the 2-character array '01')

'01'{~'0'&=

R, 27 characters

chartr("01","10",scan(,""))

Usage:

> chartr("01","10",scan(,""))
1: 10101110101010010100010001010110101001010
2: 
Read 1 item
[1] "01010001010101101011101110101001010110101"

C#, 131 bytes

A little late to the party, but here's mine. :)

using System;class R{static void Main(string[]a){foreach(var v in a[0].ToCharArray()){Console.Write(int.Parse(v.ToString())^1);}}}

Befunge 93, 25 bytes

0>~1+:#v_$>:#,_@
 ^   -1<

Assuming empty stack and EOF both read -1.

0 pushes a \0 as a null terminator

>~1+:#v_ is an input loop, it reads ascii, adds 1, checks for EOF+1=0,

^ -1< else subtracts 1 and leaves the pushed ascii value on the stack.

$>:#,_@ drops the extra copy of zero on top of the stack, then prints the binary string top to bottom

If empty stack reads 0, save 2 bytes with

>~:1+#v_$>:#,_@
^   -1<

A version around 15 bytes is possible using this same algorithm if EOF = 0, but I don't have such an implementation handy to test with.

MATLAB, 13 bytes

@(x)[97-x '']

After running the above, simply call the function with your input string to get the inverted string. For example running:

ans('10101110101010010100010001010110101001010')

prints:

01010001010101101011101110101001010110101

BotEngine, 4x8=32

Noncompeting as the language postdates the question.

Iv2 0 12
 >e>S SS
    e1e0
   ^< <P

With highlighting:

Javascript ES6, 26 chars

s=>s.replace(/\d/g,x=>x^1)

Cobra - 89

class P
    def main
        r=''
        for i in Console.readLine,r+=if(i==c'1','0','1')
        print r

C# in LINQPad, 64 63

foreach(var c in Console.ReadLine())Console.Write((char)(c^1));

EDIT: removed one character by using XOR 1