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.

J (5)

Assumes the input string is in variable b.

b='0'

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

Bash+coreutils, 8 bytes

tr 01 10

Takes input from STDIN.

Or

sed, 8 bytes

y/01/10/

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.

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/

C: 29

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

Try it online here.

Thanks for pointing out the XOR trick, Dennis.

Brainfuck (70)

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

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

Perl, 9 characters

'y/10/01/'

The 9th character is the 'p' flag

Usage:

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

Javascript (ES6) 36

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

Python 2.7 – 29

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

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

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

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

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

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

And backticks can be used instead of str()

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

Reduced to 44 from 29 thanks to pointers from @TheRare

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

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

Cobra - 89

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

Ruby: 23

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

C# in LINQPad, 64

foreach(var c in Console.ReadLine())Console.Write((char)(97-c));

PHP > 5.4 -- 37 characters

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

$s is the input

Try it online

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 - 19 bytes

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

Yea, not really original, I guess!

x86 machine code on DOS - 27 25 bytes

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

Can be easily run in DosBox as a .COM file; expects the input on the command line.

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:
    mov ah, 4ch
    int 21h

Ruby, 37

ARGV[0].each_char{|x|p x.to_i==0?1:0}

Scala, 33 bytes

print(readLine map(c=>"10"(c&1)))

Tcl - 23 bytes

string map {0 1 1 0} $s

Not quite the shortest but highly readable.

python, 34

''.join([str(int(c)^1)for c in s])