text:
Approximate a Bell Curve
Create a program to display some approximation of a bell curve. You are free to use whatever method you wish for generating the data, but the data must be displayed vertically, as in oriented like so:

Other restrictions:

Your code must create the approximation, that is, don't hardcode or take data from the internet.
The shape must actually look like a bell.

This is a popularity-contest, so be creative.

Sorry for not remembering to ask this when it was in the sandbox, but is ASCII-art ok?

@Victor Of course. (as long as you orient vertically)

What does "actually generate" mean?

@Doorknob no stealing from internet. No hard-coding. etc

What is etc? That rule needs clarification. What about getInternetBellCurve+0? What does "hard-coding" imply? This rule is currently highly opinion based.

There are many different types of bell curves: e.g., e.g.. Does the approximation used need to be a normal distribution, or many something similar also be used?

@Doorknob The "etc" means "any other cheating method to avoid actually generating the curve by getting it already done from somewhere else".

@primo Anything is valid (as long as it is a bell curve).

Will you exclude automated image generation like R and Mathematica?

@Victor ...which is subjective. How far does that go? Does getting the data externally and building the graph in your program count? How about calculating the data in your program and then creating the graph externally? What if you use an online resource to create your image? etc. etc. etc. This rule is too subjective.

@qwr Just remember this is a popularity-contest

@Doorknob, I think that this depends on which external data you are getting. If you are measuring something that has a normal distribution, this is probably ok. If you are getting an array that contains the height of the pixels for each column, it probably isn't.

Related: http://codegolf.stackexchange.com/questions/9070/normal-distribution-values

Java
The method of generation is based off of the game Sugar, Sugar. In that game, sugar particles fall, traveling randomly left and right. In my program, Dust objects fall until they hit the ground. I collect data based on where they land; this is the bell curve:
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.Random;
import java.util.Stack;
import javax.imageio.ImageIO;

/**
 *
 * @author Quincunx
 */
public class ApproxBellCurve {

    public static final int NUM_DUST = 10_000_000;
    public static final int NUM_THREADS = Runtime.getRuntime().availableProcessors() - 1;
    public static final int LOOP_LIMIT = NUM_DUST / (NUM_THREADS + 1);

    public static void main(String[] args) {
        BufferedImage output = new BufferedImage(2049, 2049, BufferedImage.TYPE_INT_RGB);

        Stack<Thread> threads = new Stack();

        for (int i = 0; i < NUM_THREADS; i++) {
            threads.push(new Thread(new Duster()));
            threads.peek().start();
        }

        Dust d;
        Random r = new Random();
        for (int i = 0; i < LOOP_LIMIT + NUM_DUST - (LOOP_LIMIT * (NUM_THREADS + 1)); i++) {
            d = new Dust(r);
            while (!d.end) {
                d.step();
            }
            if ((i & 1024) == 0) {
                r = new Random();
            }
        }
        while (threads.size() > 0) {
            try {
                threads.pop().join();
            } catch (InterruptedException ex) {

            }
        }
        int maxy = 0;
        for (int x = 0; x < Dust.data.length; x++) {
            maxy = Dust.data[x] > maxy ? Dust.data[x] : maxy;
        }

        for (int x = 0; x < Dust.data.length; x++) {
            for (int y = 0; y < output.getHeight(); y++) {
                output.setRGB(x, y, (y >= output.getHeight() - (Dust.data[x] * output.getHeight() / maxy)) ? 6591981 : 16777215);
            }
        }
        try {
            ImageIO.write(output, "png", new File("Filepath"));
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }

    private static class Duster implements Runnable {

        @Override
        public void run() {
            Dust d;
            Random r = new Random();
            for (int i = 0; i < LOOP_LIMIT; i++) {
                d = new Dust(r);
                while (!d.end) {
                    d.step();
                }
                if ((i & 1024) == 0) {
                    r = new Random();
                }
            }
        }

    }

    private static class Dust {

        public static int[] data = new int[2049];

        static {
            for (int i = 0; i < data.length; i++) {
                data[i] = 0;
            }
        }

        private int[] location;
        private Random r;
        public boolean end;

        public Dust(Random rand) {
            location = new int[]{1024, 0};
            r = rand;
            end = false;
        }

        public void step() {
            if (end) {
                return;
            }
            if (location[1] >= 1024) {
                end = true;
                synchronized (data) {
                    data[location[0]] += 1;
                }
                return;
            }
            location[1] += 1;
            location[0] += r.nextInt(21) - 10;
        }
    }
}

Sample output (took 1 minute to create):

Because of the nature of the random number generation, it is possible to get an ArrayIndexOutOfBoundsException.
I used multithreading to speed up the process. The program determines the number of processors available and creates that many threads to run the simulations.
To obtain a finer image, NUM_DUST can be increased, but that would also lead to an increased risk of an ArrayIndexOutOfBoundsException.
Each thread creates a new Random after every 1024 Dust objects are simulated. When that code was removed, the image was more coarse.
rand.nextInt(21) - 10 is to widen the distribution. A change to rand.nextInt(3) - 1 would remove all chance of an ArrayIndexOutOfBoundsException.

Mathematica
I decided it should not only look like a bell curve, it should look like a bell. So hey, let's spin it around the Z-axis and make it 3D.
And hey, while we're at it, it should sound like a bell as well.
So, each time you evaluate the code, it makes a nice pleasing church-bell BWONNGGG!
Manipulate[
 RevolutionPlot3D[PDF[NormalDistribution[mu, sigma], x], {x, -4, 4},
  PlotRange -> {Automatic, Automatic, Automatic},
  BoxRatios -> {1, 1, 1}, PlotStyle -> {Orange, Yellow},
  ImageSize -> {500, 500}], {{mu, 0, "mean"}, -3, 3,
  Appearance -> "Labeled"}, {{sigma, 1.47, "standard deviation"}, .5,
  2, Appearance -> "Labeled"}]
EmitSound[Sound[SoundNote[0, 3, "TubularBells", SoundVolume -> 1]]]

Here's what it looks like:

And here's a brief video of the bell ringing.

Haskell, 9 LoC
Everyone's code is so ... huge, and their approximations are ... less than deterministic. Just to remind everyone of the simplicity of the actual task, here's a nine-liner in Haskell:
import Data.List; import Data.Ratio
main = do
  putStrLn "please choose the width and the maximum height:"
  [w, mh] <- (map read.words) `fmap` getLine
  let dist = map length $ group $ sort $ map length $ subsequences [2..w]
      scale = ceiling $ maximum dist % mh
      maxD = scale * ceiling (maximum dist % scale)
  putStrLn $ unlines $ map (row dist) [maxD, maxD - scale .. 0]
      where row dist y = map (\x -> if x >= y then '*' else ' ') dist

OK... that wasn't exactly fast. Here's another go. Does it still count as not hard-coded?
import Data.List; import Data.Ratio

main = do
  putStrLn "please choose the width and the maximum height:"
  [w, mh] <- (map read.words) `fmap` getLine
  let dist = map ((w-1) `choose`) [0..(w-1)]
      scale = ceiling $ maximum dist % mh
      maxD = scale * ceiling (maximum dist % scale)
  putStrLn $ unlines $ map (row dist) [maxD, maxD - scale .. 0]
      where row dist y = map (\x -> if x >= y then '*' else ' ') dist

factorial x = product [1..x]
n `choose` k = factorial n `div` factorial k `div` factorial (n-k)

You mean, "Them Java users' code is so huge." The other people's codes are rather small. Also, is there anything wrong with long code? I personally enjoy popularity-contests because I am free to make my code as long as I want to.

@Quincunx Hmm... true. But I'm still shorter than the non-Java solutions :-) as for whether long code or short code should be preferred in this challenge, that's up to voters. I offer consciseness.

Yours is huge compared to mine. :P

Wolfram Alpha (tongue-in-cheek) 4 bytes:
Here is a practical application of the Central Limit Theorem. I even golfed it!
Type this into the input box on Wolfram Alpha:
3d20

Here is a link to the results. It interprets this input as 3 icosahedral dice, and decides you want a graph of the distribution function of the pip sums. It prints the following graph:

We can make the graph more and more bell shaped by adding more dice. I don't see this as taking my data from the internet since, if I could run the query engine for it on my home computer I would. Unfortunately, Wolfram Research doesn't provide it for download, though.

You can get a better looking curve with more dice and die-faces: https://www.wolframalpha.com/input/?i=10d50

@Quincunx I wanted to keep it to 20 sided dice so that it could actually be done with physical dice that are fair. I think 20d20 looks pretty good though: https://www.wolframalpha.com/input/?i=20d20

@Quincunx Oh, I didn't know you could hotlink images here... I learn something new all the time

@Quincunx I rolled back your edit, because the link went dead.

Mathematica
Generating the sums of 5 random integers, each between 0 and 100, 20000 times.
Histogram[Plus @@@ RandomInteger[100, {20000, 5}]]

Here's the result for sums of 1,2, 3 numbers.  As the number of integers to be summed increases, the curve approaches the bell shape.
When single random integers are generated, but not summed, the distribution should be fairly uniform, not favoring any value. The apparent anomaly for 100 may be the result of how Matheamtica bins data. (see https://mathematica.stackexchange.com/questions/43300/does-randominteger0-n-disfavor-n/43302#43302 )
Table[Histogram[Plus @@@ RandomInteger[100, {20000, k}]], {k, 1, 3}]

C#, WPF
Rough approximation with a hand-crafted Bézier curve. To make it more interesting: No use of Line, Path or similar, only Ellipse.

public MainWindow()
{
    InitializeComponent();
    // Requires a Canvas named Canvas in XAML file
    DrawBellCurve(Canvas, 300, 300);
}

public static void DrawBellCurve(Canvas canvas, int width, int height)
{
    Point p1 = new Point(0, height);
    Point p2 = new Point(0.3 * width, 1 * height);
    Point p3 = new Point(0.4 * width, 0.1 * height);
    Point peak = new Point(width / 2, 0);
    Point p3r = new Point(width - p3.X, p3.Y);
    Point p2r = new Point(width - p2.X, p2.Y);
    Point p1r = new Point(width, height);
    List<Point> controlPoints = new List<Point> { p1, p2, p3, peak, p3r, p2r, p1r };

    DrawBezierCurve(canvas, controlPoints, Color.FromRgb(50, 200, 25));
    DrawPoints(canvas, controlPoints, 5, Color.FromRgb(80, 80, 220));
}

public static void DrawPoints(Canvas canvas, List<Point> points, double radius, Color color)
{
    foreach (var p in points)
    {
        Ellipse ellipse = new Ellipse();
        ellipse.Width = radius;
        ellipse.Height = radius;
        ellipse.SetValue(Canvas.LeftProperty, p.X - radius / 2);
        ellipse.SetValue(Canvas.TopProperty, p.Y - radius / 2);
        ellipse.Fill = new SolidColorBrush(color);
        canvas.Children.Add(ellipse);
    }
}

public static void DrawBezierCurve(Canvas canvas, List<Point> controlPoints, Color color)
{
    var curvePoints = new List<Point>();
    double tStep = 0.01;
    for (double t = 0; t <= 1; t += tStep)
    {
        curvePoints.Add(GetBezierPoint(controlPoints, t));
    }

    DrawPoints(canvas, curvePoints, 3, color);
}

public static Point GetBezierPoint(List<Point> controlPoints, double t)
{
    // De Casteljau's algorithm
    if (controlPoints.Count == 1)
    {
        return controlPoints[0];
    }

    var newControlPoints = new List<Point>();
    for (int i = 0; i < controlPoints.Count - 1; i++)
    {
        Point p1 = controlPoints[i];
        Point p2 = controlPoints[i + 1];
        Point p = new Point(
            t * p1.X + (1 - t) * p2.X,
            t * p1.Y + (1 - t) * p2.Y);
        newControlPoints.Add(p);
    }
    return GetBezierPoint(newControlPoints, t);
}

Ruby
Simulates the classic example of bell curves, dropping a ball down a grid full of pole thingies.
a = [0]*30
1000.times do
  x = 15
  49.times do
    x += (rand(3) - 1)
  end
  a[[[x.to_i, 29].min, 0].max] += 1
end
until a.all?{|x| x == 0}
  a.each_with_index{|x,i|
    if x == 0
      print ' '
    else
      print 'x'
      a[i] -= 1
    end
  }
  puts
end

Sample output:
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  xxxxxxxxxxxxxxxxxxxxxxxxxx
  xxxxxxxxxxxxxxxxxxxxxxxxxx
  xxxxxxxxxxxxxxxxxxxxxxxxxx
  x xxxxxxxxxxxxxxxxxxxxxxxx
    xxxxxxxxxxxxxxxxxxxxxxxx
    xxxxxxxxxxxxxxxxxxxxxxxx
    xxxxxxxxxxxxxxxxxxxxxxxx
     xxxxxxxxxxxxxxxxxxxxxxx
     xxxxxxxxxxxxxxxxxxxx
     xxxxxxxxxxxxxxxxxxxx
     xxxxxxxxxxxxxxxxxxxx
     xxxxxxxxxxxxxxxxxxxx
     xxxxxxxxxxxxxxxxxxxx
     xxxxxxxxxxxxxxxxxxxx
     xxxxxxxxxxxxxxxxxxxx
     xxxxxxxxxxxxxxxxxxx
      xxxxxxxxxxxxxxxxxx
      xxxxxxxxxxxxxxxxxx
      xxxxxxxxxxxxxxxxxx
      xxxxxxxxxxxxxxxxxx
       xxxxxxxxxxxxxxxxx
        xxxxxxxxxxxxxxxx
        xxxxxxxxxxxxxxxx
        xxxxxxxxxxxxxxx
        xxxxxxxxxxxxxxx
        xxxxxxxxxxxxxxx
        xxxxxxxxxxxxxxx
        xxxxxxxxxxxxxxx
        xxxxxxxxxxxxxxx
        xxxxxxxxxxxxxxx
        xxxxxxxxxxxxxxx
        xxxxxxxxxxxxxx
        xxxxxxxxxxxxxx
         xxxxxxxxxxxxx
         xxxxxxxxxxxxx
         xxxxxxxxxxxxx
         xxxxxxxxxxxxx
         xxxxxxxxxxxxx
         xxxxxxxxxxxxx
         xxxxxxxxxxxx
          xxxxxxxxxxx
          xxxxxxxxxxx
          xxxxxxxxxxx
          xxxxxxxxxxx
           xxxxxxxxxx
           xxxxxxxxxx
           xxxxxxxxxx
           xxxxxxx xx
           xxxxxxx xx
           xxxxxxx xx
            xxxxxx xx
            xxxxxx xx
            xxxxxx x
            xxxxx  x
            xxxxx  x
              xxx  x
              xxx  x
              xxx  x
              xxx  x
              xxx  x
              xxx
              xxx
              xxx
              xxx
              xxx
              xxx
              xxx
              xxx
              xxx
              x x
              x x
              x x
              x x
              x
              x
              x

Oh, did I forget to mention it's upside down?

+1 for hiding the most abnormal part of the curve below the fold. Genius!  :)

Python
from pygame import*
t,u=640,400;init();d=display;s=d.set_mode((t,u))
s.fill(0xFFFFFF)
for x in range(t):
  d.flip();event.get()
  draw.line(s,u,(x,int(u-2**(-((x-t*.5)/120)**2)*u)),(x,u))

while time.wait(50):
 for e in event.get():
  if e.type==QUIT:exit()

This is actually a normal distribution, using 2 as the base of the exponent instead of e, and not dividing by ⎷2π, because without axes, it doesn't really matter if the area under the curve isn't exactly 1.

The last 3 lines just keep the window open until the user closes it manually.

Java
Throwing 6 dice in every possible combination approaches a 'normal distribution', which happens to be a bell curve.
public class Temp {
    public static void main(String[] args) throws Exception {
        int[] hist = new int[31];
        for (int d1 = 0; d1 < 6; d1++)
            for (int d2 = 0; d2 < 6; d2++)
                for (int d3 = 0; d3 < 6; d3++)
                    for (int d4 = 0; d4 < 6; d4++)
                        for (int d5 = 0; d5 < 6; d5++)
                            for (int d6 = 0; d6 < 6; d6++)
                                hist[d1 + d2 + d3 + d4 + d5 + d6]++;
        for (int y = 4104; y >= 0; y -= 228)
            for (int x = 0; x < 32; x++)
                System.out.print(x == 31? '\n' : hist[x] <= y? '\u3000' : (char)('\u2580' + Math.min(Math.ceil((hist[x] - y) / 28.5), 8)));
    }
}

Some Unicode tricks make the output smoother:
　　　　　　　　　　　　　　▅█▅
　　　　　　　　　　　　　▂███▂
　　　　　　　　　　　　　█████
　　　　　　　　　　　　▁█████▁
　　　　　　　　　　　　███████
　　　　　　　　　　　　███████
　　　　　　　　　　　▅███████▅
　　　　　　　　　　　█████████
　　　　　　　　　　　█████████
　　　　　　　　　　▇█████████▇
　　　　　　　　　　███████████
　　　　　　　　　▃███████████▃
　　　　　　　　　█████████████
　　　　　　　　▁█████████████▁
　　　　　　　　███████████████
　　　　　　　▃███████████████▃
　　　　　　　█████████████████
　　　　　▁███████████████████▁
▁▁▁▂▅█████████████████████▅▂▁▁▁

Java 8
It gets the height and the width from the user, chooses width random booleans and count how many are true, registering the counted frequency. Repeat this until some of the generated frequencies is enough to fill the height:
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.image.BufferedImage;
import java.util.Random;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JOptionPane;

public class Bell {
    public static int[] bell(int width, int height) {
        // I could have used Random.nextGaussian() method, but this way is more fun.
        Random r = new Random();
        int max = 0;
        int[] freqs = new int[width];
        for (int j = 0; max < height - 1; j++) {
            int count = 0;
            for (int i = 0; i < width; i++) {
                if (r.nextBoolean()) count++;
            }
            freqs[count]++;
            if (freqs[count] > max) max++;
        }
        return freqs;
    }

    public static BufferedImage drawBell(int[] ps, int width, int height) {
        BufferedImage bi = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
        for (int i = 0; i < width; i++) {
            for (int j = 0; j < ps[i]; j++) {
                bi.setRGB(i, height - j - 1, 0xFF00FFFF); // Cyan
            }
            for (int m = i - 1; m <= i + 1; m++) {
                if (m < 0 || m >= width) continue;
                for (int n = ps[i] - 1; n <= ps[i] + 1; n++) {
                    if (n < 0 || n >= height) continue;
                    bi.setRGB(m, height - n - 1, 0xFF0000FF); // Blue
                }
            }
            for (int j = ps[i] + 1; j < height; j++) {
                bi.setRGB(i, height - j - 1, 0xFFFFFFFF); // White
            }
        }
        return bi;
    }

    public static void main(String[] args) {
        String a = JOptionPane.showInputDialog("Give the width:");
        String b = JOptionPane.showInputDialog("Give the height:");

        int w, h;
        try {
            w = Integer.parseInt(a);
        } catch (NumberFormatException e) {
            JOptionPane.showMessageDialog(null, "Invalid width.");
            return;
        }

        try {
            h = Integer.parseInt(b);
        } catch (NumberFormatException e) {
            JOptionPane.showMessageDialog(null, "Invalid height.");
            return;
        }

        int[] freqs = bell(w, h);
        BufferedImage image = drawBell(freqs, w, h);

        EventQueue.invokeLater(() -> {
            JFrame j = new JFrame("Bell curve");
            j.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
            j.add(new SimpleSprite(image));
            j.setResizable(false);
            j.pack();
            j.setVisible(true);
        });
    }

    public static class SimpleSprite extends JComponent {
        private final BufferedImage image;
        private final Dimension dim;

        public SimpleSprite(BufferedImage image) {
            this.image = image;
            this.dim = new Dimension(image.getWidth(), image.getHeight());
        }

        @Override
        public Dimension getMinimumSize() {
            return dim;
        }

        @Override
        public Dimension getMaximumSize() {
            return dim;
        }

        @Override
        public Dimension getPreferredSize() {
            return dim;
        }

        @Override
        public void paintComponent(Graphics g) {
            g.drawImage(image, 0, 0, null);
        }
    }
}

Screenshot:

GeoGebra
I don't know whether it is valid to use an application that is made to draw graphs, but if you enter this in the input, you get a Bell Curve:
f(x) = 3ℯ^(-(x - 1)²)

Or, if you want a customizable bell curve:
a = 0
b = 0
c = 0
d = 0
f(x) = a ℯ^((-(x - b)²) / 2 c²) + d

Then, make sure that you enable the sliders for the variables (if they are disabled, click on the circle next to the variable names). Then, you can set a value for them by sliding.
Image of the curve with the sliders (click to enlarge):

Although the rules didn't technically require posting them, give us the visuals! We'd love to see the result. And is this program specifically designed to give accessibility options for disabled users? That is great!

@JonathanVanMatre: Done.

Haha, I see now I made a parsing error when reading your text. Nice graph, though!

It's a cool program, fun to mess around with.

Python and tkinter
I liked Doorknob's generation method and Victor's output (his generation is actually equivalent), so I decided to combine the two with tkinter!
from tkinter import *
import random

bins = [0]*201
for i in range(20000):
    x = 0
    for j in range(100):
        if random.randint(0, 1):
            x += 0.5
        else:
            x -= 0.5
    bins[int(x)+100] += 1

master = Tk()

w = Canvas(master, width = 201, height=200)
w.pack()

for i in range(201):
    w.create_line(i, 200, i, 200-bins[i]/10, fill="light blue")
    w.create_line(i-1, 200-bins[i-1]/10, i, 200-bins[i]/10, fill="blue")

C
Based on random walks
#include <stdio.h>
#include <stdlib.h>

#define X_SIZE 40
#define Y_SIZE 15
#define SMOOTH 100

int main(void)
{
int i,j;
int T[X_SIZE*2];
int w;

for (i=0; i<X_SIZE*2; i++) T[i]=0;

// random walks
do  {
    w=X_SIZE;
    for (i=0;i<X_SIZE;i++)
        w+=rand()%2?1:-1;
    T[w]++;
    }
while (T[w]<Y_SIZE*SMOOTH);

// display
for (j=Y_SIZE; j>=0; j--)
    {
    for (i=0; i<X_SIZE*2; i+=2)
        printf("%c", (T[i]>j*SMOOTH)?'#':' ');
    printf("\n");
    }

}

Output :
               ###
               ###
              #####
              #####
              #####
             #######
             #######
            #########
            #########
            #########
           ###########
           ###########
          #############
         ###############
     #######################

Octave
c=79;
x=ifft(fft([ones(1,10) zeros(1,c-10)]).^8);
y=(1:c)*0+' ';
for l=-24:-1,
  for k=1:c,
    if -real(x(k))<l*2e5,
      y(k)='*';
    end
  end
  printf([char(y) '\n'])
end

Try it online!
Instead of directly simulating coin flips, this just uses the observation that the pdf of a sum of random variables is the convolution of the pdfs of each of the random variables. An efficient way to do circular convolution is to take the inverse fourier transform of the element-wise product of the fourier transforms of the pdfs of each of the random variables. For the purpose of this problem (not true in general) circular convolution can stand in for linear convolution.
As an example, given the following pdf of a uniform random variable.
                           **********
                           **********
                           **********
                           **********
                           **********
                           **********
                           **********
                           **********
                           **********
                           **********
                           **********
                           **********

The above random variable summed with itself
                                *
                               ***
                               ***
                              *****
                             *******
                            *********
                           ***********
                           ***********
                          *************
                         ***************
                        *****************
                       *******************

The uniform random variable summed with itself 7 times.
                                *
                             *******
                           ***********
                          *************
                         ***************
                        *****************
                       *******************
                     ***********************
                    *************************
                   ***************************
                 *******************************
              *************************************

J
load 'plot'
plot (3+i.58)([:+/=)"0 1]3+([:+/?,?,?)"0]1e6#20

Not very creative, but still fun!
Throws three twenty sided dice 1000000 times, summing the result each time. Then to get it in a plot-ready format, we take the array [3..60] and replace each element by the number of times it occures in the random sums.
plot then creates a PDF:

Python (Box-Muller) - 6 lines
This short code uses the Box-Muller transform for simulating a normally distributed variable:
from math import cos, log, pi
from random import random

f = open("normDist.txt",'w')
for i in xrange(10**6):
    f.write(str(cos(2*pi*random())*(-2*log(random()))**.5)+'\n')
f.close()

You can plug the values on GNUPLOT or use this script
f=open("normDist.txt",'r')

v = [0 for i in xrange(51)]
for i in f:
    v[int(float(i)*10) if float(i)<5 and float(i)>-5 else 0]+=1

m=0
for i in v:
    if i>m:
        m=i
for i in v[3:]:
    for j in xrange(int(70.*i/m)):
        print '*',
    print

to produce something like this:
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * *
* * * * * * * * * * * * * *
* * * * * * * * * * * *
* * * * * * * * * *
* * * * * * * *
* * * * * * *
* * * * * *
* * * * *
* * * *
* * *
* * *
* *
* *
* *
* *
* *
* *
* * *
* * *
* * * *
* * * * *
* * * * * *
* * * * * * *
* * * * * * * *
* * * * * * * * * *
* * * * * * * * * * * *
* * * * * * * * * * * * * *
* * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

Not properly oriented according to the question. Should be rotated 90 degrees.

awk
#!/ust/bin/awk -f
BEGIN {
  #
  # do WALKS random walks with OOPS times left or right per walk
  #
  WALKS=100000
  OOPS=39
  #
  # output will be H lines
  # the line width will be 2*OOPS+1
  #
  H=23
  #
  # shake awk's pseudorandom generator
  #
  srand()
  #
  # do the walks
  #
  for(i=0;i<WALKS;i++) {
    x=0
    for(j=0;j<OOPS;j++) rand()<0.5?--x:++x
    X[x]++
  }
  #
  # scan for maximum height
  #
  M=0
  for(x=-OOPS;x<=OOPS;x++) {
    if(X[x]>M) M=X[x]
  }
  #
  # "draw" into S[x]: strings of H*X[x]/M "*"s
  #
  for(x=-OOPS;x<=OOPS;x++) {
    s=sprintf("%*s",H*X[x]/M," ")
    gsub(/./,"*",s)
    S[x]=s
  }
  #
  # print S[x] transposed
  #
  for(y=H;y>0;y--) {
    for(x=-OOPS;x<=OOPS;x++) {
      if(c=substr(S[x],y,1)) printf c
      else printf " "
    }
    print ""
  }
}

Output:
                                        *
                                      * *
                                      * *
                                    * * * *
                                    * * * *
                                    * * * *
                                    * * * *
                                  * * * * * *
                                  * * * * * *
                                  * * * * * *
                                  * * * * * *
                                * * * * * * * *
                                * * * * * * * *
                                * * * * * * * *
                                * * * * * * * *
                              * * * * * * * * * *
                              * * * * * * * * * *
                              * * * * * * * * * *
                            * * * * * * * * * * *
                            * * * * * * * * * * * *
                            * * * * * * * * * * * *
                          * * * * * * * * * * * * * *
*******************************************************************************

Stax, 20 bytes
⌐∞¶J♠fr"▐cS╥aÆ~a╚∩┌I

Run and debug it
This isn't code-golf but I still want to give Stax a try. Calculates frequency of sum of dices rolled 6 times. Note there are no support for random numbers in Stax.
ASCII equivalent:
6R6|^{|+m{o:G{AJ/'**mMrm

Output:
               *
              ***
              ***
              ***
             *****
             *****
             *****
             *****
             *****
            *******
            *******
            *******
            *******
            *******
            *******
           *********
           *********
           *********
           *********
           *********
           *********
          ***********
          ***********
          ***********
          ***********
          ***********
          ***********
         *************
         *************
         *************
         *************
         *************
        ***************
        ***************
        ***************
        ***************
       *****************
       *****************
       *****************
      *******************
      *******************
     *********************
    ***********************

Charcoal
≔⟦Ｘφ±⁹⟧θＦ⁹⁹≔Ｅ⊞Ｏθ⁰⁺κ§θ⊖λθ↑θ

Verbose version:
Assign([Power(1000, Negate(9))], q);
for (99) Assign(Map(PushOperator(q, 0), Plus(k, AtIndex(q, Decremented(l)))), q);
Print(:Up, q);

Try it online! Output:
             ||
             ||
            ||||
            ||||
            ||||
            ||||
           ||||||
           ||||||
           ||||||
           ||||||
           ||||||
          ||||||||
          ||||||||
          ||||||||
          ||||||||
          ||||||||
          ||||||||
         ||||||||||
         ||||||||||
         ||||||||||
         ||||||||||
         ||||||||||
         ||||||||||
        ||||||||||||
        ||||||||||||
        ||||||||||||
        ||||||||||||
        ||||||||||||
        ||||||||||||
       ||||||||||||||
       ||||||||||||||
       ||||||||||||||
       ||||||||||||||
       ||||||||||||||
      ||||||||||||||||
      ||||||||||||||||
      ||||||||||||||||
      ||||||||||||||||
      ||||||||||||||||
     ||||||||||||||||||
     ||||||||||||||||||
     ||||||||||||||||||
    ||||||||||||||||||||
    ||||||||||||||||||||
    ||||||||||||||||||||
   ||||||||||||||||||||||
   ||||||||||||||||||||||
  ||||||||||||||||||||||||
 ||||||||||||||||||||||||||
||||||||||||||||||||||||||||

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/


text:
Draw the Utah Teapot
The Utah teapot, originally created by Martin Newell, is a convenient object for testing 3D graphics programs.
The task is to create a wireframe image of the teapot in perspective projection. To encourage the idea of a source-code application, the viewing and camera control may be isolated and excluded from the count. This is so the parameters and input file may be modified and the code re-used to generate diverse images, but it is not necessary to create a full-fledged utility that accepts complicated command-line arguments or such. A "hackerly" balance is sought.

ref. StackOverflow: How do Bezier Patches work in the Utah Teapot?
So there are three subtasks here:

read-in the teapot data in its original format.
subdivide the patch data using deCasteljau splitting or other method. Other methods are using Bezier basis matrices and evaluating the polynomials (standard refs, like Foley and van Dam, Newmann and Sproull), or Bernstein basis methods (which are still beyond me).
project the points to 2D (if the language does not support 3D natively) and draw the outline of each small patch as seen from an Eye point whose view is centered on a LookAt point and whose vertical axis is aligned with the vertical axis of the teapot (ie. draw it "upright" from a nice vantagepoint).

Assuming that reading line-oriented text data from a file is little trouble, this challenge is really about getting hands-on with Bi-Cubic Bezier patch data.
Since the simple normal test for backface culling is not sufficient (the patches are not all oriented outward), no hidden-line or -surface removal is necessary. As a wireframe, it should look just fine with the back visible. The appearance may be improved by adjusting the line-width depending upon the distance from the eye, but this is not strictly necessary (my own programs do not do this).
This is both code-golf and rosetta-stone. Answers competing in the golf should include a count as normal. But submissions in unusual languages are very much encouraged, even if they're not particularly short.
For Kolmogorov-complexity enthusiasts, there is a more concise dataset where the full set may be reconstructed by adding rotations and mirroring of patches. And in Jim Blinn's A Trip Down the Graphics Pipeline, there is an even more concise method of generation by using the fact that the individual patches have rotational or other symmetries. The entire body (or lid) can be described by a single Bezier curve which is rotated around the y-axis. The spout and handles can be described by the two curves of their profile, and then selecting the intermediate control points to approximate a circular extrusion.

Should i include the count of the array of point in my count?

I would rather see it coming from a file, ... but no, no need to count the patch data however it comes.

I’d suggest disallowing builtins like glutSolidTeapot and glutWireTeapot!

@AndersKaseorg I think I covered that by requiring to read-in the original data. ...That said, I have been lax in enforcing this rule. A more closely valid answer would easily take the checkmark, even if it's longer.

@luserdroog Imagine a solution that reads the original data, ignores it, and calls glutWireTeapot.

This question does not appear to fit the [tag:rosetta-stone] tag description. A [tag:rosetta-stone] challenge involves the answers providing solutions in a number of different languages not the answers providing solutions in "unusual" languages.

Processing (java), 314 (237 without camera control)
Not including the array definitions:
void setup(){size(640,480,P3D);}void draw(){background(0);noFill();stroke(255);translate(width/2,height/2,70);scale(30);rotateX(map(mouseX,0,width,0,TWO_PI));rotateY(map(mouseY,0,height,0,TWO_PI));for(int[] p:patches){beginShape();for(int pt:p){vertex(data[pt-1][0],data[pt-1][1],data[pt-1][2]);}endShape(CLOSE);}}

Data array definitions:
float [][] data = {{1.4,0.0,2.4},
{1.4,-0.784,2.4},
{0.784,-1.4,2.4},
{0.0,-1.4,2.4},
{1.3375,0.0,2.53125},
{1.3375,-0.749,2.53125},
{0.749,-1.3375,2.53125},
{0.0,-1.3375,2.53125},
{1.4375,0.0,2.53125},
{1.4375,-0.805,2.53125},
{0.805,-1.4375,2.53125},
{0.0,-1.4375,2.53125},
{1.5,0.0,2.4},
{1.5,-0.84,2.4},
{0.84,-1.5,2.4},
{0.0,-1.5,2.4},
{-0.784,-1.4,2.4},
{-1.4,-0.784,2.4},
{-1.4,0.0,2.4},
{-0.749,-1.3375,2.53125},
{-1.3375,-0.749,2.53125},
{-1.3375,0.0,2.53125},
{-0.805,-1.4375,2.53125},
{-1.4375,-0.805,2.53125},
{-1.4375,0.0,2.53125},
{-0.84,-1.5,2.4},
{-1.5,-0.84,2.4},
{-1.5,0.0,2.4},
{-1.4,0.784,2.4},
{-0.784,1.4,2.4},
{0.0,1.4,2.4},
{-1.3375,0.749,2.53125},
{-0.749,1.3375,2.53125},
{0.0,1.3375,2.53125},
{-1.4375,0.805,2.53125},
{-0.805,1.4375,2.53125},
{0.0,1.4375,2.53125},
{-1.5,0.84,2.4},
{-0.84,1.5,2.4},
{0.0,1.5,2.4},
{0.784,1.4,2.4},
{1.4,0.784,2.4},
{0.749,1.3375,2.53125},
{1.3375,0.749,2.53125},
{0.805,1.4375,2.53125},
{1.4375,0.805,2.53125},
{0.84,1.5,2.4},
{1.5,0.84,2.4},
{1.75,0.0,1.875},
{1.75,-0.98,1.875},
{0.98,-1.75,1.875},
{0.0,-1.75,1.875},
{2.0,0.0,1.35},
{2.0,-1.12,1.35},
{1.12,-2.0,1.35},
{0.0,-2.0,1.35},
{2.0,0.0,0.9},
{2.0,-1.12,0.9},
{1.12,-2.0,0.9},
{0.0,-2.0,0.9},
{-0.98,-1.75,1.875},
{-1.75,-0.98,1.875},
{-1.75,0.0,1.875},
{-1.12,-2.0,1.35},
{-2.0,-1.12,1.35},
{-2.0,0.0,1.35},
{-1.12,-2.0,0.9},
{-2.0,-1.12,0.9},
{-2.0,0.0,0.9},
{-1.75,0.98,1.875},
{-0.98,1.75,1.875},
{0.0,1.75,1.875},
{-2.0,1.12,1.35},
{-1.12,2.0,1.35},
{0.0,2.0,1.35},
{-2.0,1.12,0.9},
{-1.12,2.0,0.9},
{0.0,2.0,0.9},
{0.98,1.75,1.875},
{1.75,0.98,1.875},
{1.12,2.0,1.35},
{2.0,1.12,1.35},
{1.12,2.0,0.9},
{2.0,1.12,0.9},
{2.0,0.0,0.45},
{2.0,-1.12,0.45},
{1.12,-2.0,0.45},
{0.0,-2.0,0.45},
{1.5,0.0,0.225},
{1.5,-0.84,0.225},
{0.84,-1.5,0.225},
{0.0,-1.5,0.225},
{1.5,0.0,0.15},
{1.5,-0.84,0.15},
{0.84,-1.5,0.15},
{0.0,-1.5,0.15},
{-1.12,-2.0,0.45},
{-2.0,-1.12,0.45},
{-2.0,0.0,0.45},
{-0.84,-1.5,0.225},
{-1.5,-0.84,0.225},
{-1.5,0.0,0.225},
{-0.84,-1.5,0.15},
{-1.5,-0.84,0.15},
{-1.5,0.0,0.15},
{-2.0,1.12,0.45},
{-1.12,2.0,0.45},
{0.0,2.0,0.45},
{-1.5,0.84,0.225},
{-0.84,1.5,0.225},
{0.0,1.5,0.225},
{-1.5,0.84,0.15},
{-0.84,1.5,0.15},
{0.0,1.5,0.15},
{1.12,2.0,0.45},
{2.0,1.12,0.45},
{0.84,1.5,0.225},
{1.5,0.84,0.225},
{0.84,1.5,0.15},
{1.5,0.84,0.15},
{-1.6,0.0,2.025},
{-1.6,-0.3,2.025},
{-1.5,-0.3,2.25},
{-1.5,0.0,2.25},
{-2.3,0.0,2.025},
{-2.3,-0.3,2.025},
{-2.5,-0.3,2.25},
{-2.5,0.0,2.25},
{-2.7,0.0,2.025},
{-2.7,-0.3,2.025},
{-3.0,-0.3,2.25},
{-3.0,0.0,2.25},
{-2.7,0.0,1.8},
{-2.7,-0.3,1.8},
{-3.0,-0.3,1.8},
{-3.0,0.0,1.8},
{-1.5,0.3,2.25},
{-1.6,0.3,2.025},
{-2.5,0.3,2.25},
{-2.3,0.3,2.025},
{-3.0,0.3,2.25},
{-2.7,0.3,2.025},
{-3.0,0.3,1.8},
{-2.7,0.3,1.8},
{-2.7,0.0,1.575},
{-2.7,-0.3,1.575},
{-3.0,-0.3,1.35},
{-3.0,0.0,1.35},
{-2.5,0.0,1.125},
{-2.5,-0.3,1.125},
{-2.65,-0.3,0.9375},
{-2.65,0.0,0.9375},
{-2.0,-0.3,0.9},
{-1.9,-0.3,0.6},
{-1.9,0.0,0.6},
{-3.0,0.3,1.35},
{-2.7,0.3,1.575},
{-2.65,0.3,0.9375},
{-2.5,0.3,1.125},
{-1.9,0.3,0.6},
{-2.0,0.3,0.9},
{1.7,0.0,1.425},
{1.7,-0.66,1.425},
{1.7,-0.66,0.6},
{1.7,0.0,0.6},
{2.6,0.0,1.425},
{2.6,-0.66,1.425},
{3.1,-0.66,0.825},
{3.1,0.0,0.825},
{2.3,0.0,2.1},
{2.3,-0.25,2.1},
{2.4,-0.25,2.025},
{2.4,0.0,2.025},
{2.7,0.0,2.4},
{2.7,-0.25,2.4},
{3.3,-0.25,2.4},
{3.3,0.0,2.4},
{1.7,0.66,0.6},
{1.7,0.66,1.425},
{3.1,0.66,0.825},
{2.6,0.66,1.425},
{2.4,0.25,2.025},
{2.3,0.25,2.1},
{3.3,0.25,2.4},
{2.7,0.25,2.4},
{2.8,0.0,2.475},
{2.8,-0.25,2.475},
{3.525,-0.25,2.49375},
{3.525,0.0,2.49375},
{2.9,0.0,2.475},
{2.9,-0.15,2.475},
{3.45,-0.15,2.5125},
{3.45,0.0,2.5125},
{2.8,0.0,2.4},
{2.8,-0.15,2.4},
{3.2,-0.15,2.4},
{3.2,0.0,2.4},
{3.525,0.25,2.49375},
{2.8,0.25,2.475},
{3.45,0.15,2.5125},
{2.9,0.15,2.475},
{3.2,0.15,2.4},
{2.8,0.15,2.4},
{0.0,0.0,3.15},
{0.0,-0.002,3.15},
{0.002,0.0,3.15},
{0.8,0.0,3.15},
{0.8,-0.45,3.15},
{0.45,-0.8,3.15},
{0.0,-0.8,3.15},
{0.0,0.0,2.85},
{0.2,0.0,2.7},
{0.2,-0.112,2.7},
{0.112,-0.2,2.7},
{0.0,-0.2,2.7},
{-0.002,0.0,3.15},
{-0.45,-0.8,3.15},
{-0.8,-0.45,3.15},
{-0.8,0.0,3.15},
{-0.112,-0.2,2.7},
{-0.2,-0.112,2.7},
{-0.2,0.0,2.7},
{0.0,0.002,3.15},
{-0.8,0.45,3.15},
{-0.45,0.8,3.15},
{0.0,0.8,3.15},
{-0.2,0.112,2.7},
{-0.112,0.2,2.7},
{0.0,0.2,2.7},
{0.45,0.8,3.15},
{0.8,0.45,3.15},
{0.112,0.2,2.7},
{0.2,0.112,2.7},
{0.4,0.0,2.55},
{0.4,-0.224,2.55},
{0.224,-0.4,2.55},
{0.0,-0.4,2.55},
{1.3,0.0,2.55},
{1.3,-0.728,2.55},
{0.728,-1.3,2.55},
{0.0,-1.3,2.55},
{1.3,0.0,2.4},
{1.3,-0.728,2.4},
{0.728,-1.3,2.4},
{0.0,-1.3,2.4},
{-0.224,-0.4,2.55},
{-0.4,-0.224,2.55},
{-0.4,0.0,2.55},
{-0.728,-1.3,2.55},
{-1.3,-0.728,2.55},
{-1.3,0.0,2.55},
{-0.728,-1.3,2.4},
{-1.3,-0.728,2.4},
{-1.3,0.0,2.4},
{-0.4,0.224,2.55},
{-0.224,0.4,2.55},
{0.0,0.4,2.55},
{-1.3,0.728,2.55},
{-0.728,1.3,2.55},
{0.0,1.3,2.55},
{-1.3,0.728,2.4},
{-0.728,1.3,2.4},
{0.0,1.3,2.4},
{0.224,0.4,2.55},
{0.4,0.224,2.55},
{0.728,1.3,2.55},
{1.3,0.728,2.55},
{0.728,1.3,2.4},
{1.3,0.728,2.4},
{0.0,0.0,0.0},
{1.5,0.0,0.15},
{1.5,0.84,0.15},
{0.84,1.5,0.15},
{0.0,1.5,0.15},
{1.5,0.0,0.075},
{1.5,0.84,0.075},
{0.84,1.5,0.075},
{0.0,1.5,0.075},
{1.425,0.0,0.0},
{1.425,0.798,0.0},
{0.798,1.425,0.0},
{0.0,1.425,0.0},
{-0.84,1.5,0.15},
{-1.5,0.84,0.15},
{-1.5,0.0,0.15},
{-0.84,1.5,0.075},
{-1.5,0.84,0.075},
{-1.5,0.0,0.075},
{-0.798,1.425,0.0},
{-1.425,0.798,0.0},
{-1.425,0.0,0.0},
{-1.5,-0.84,0.15},
{-0.84,-1.5,0.15},
{0.0,-1.5,0.15},
{-1.5,-0.84,0.075},
{-0.84,-1.5,0.075},
{0.0,-1.5,0.075},
{-1.425,-0.798,0.0},
{-0.798,-1.425,0.0},
{0.0,-1.425,0.0},
{0.84,-1.5,0.15},
{1.5,-0.84,0.15},
{0.84,-1.5,0.075},
{1.5,-0.84,0.075},
{0.798,-1.425,0.0},
{1.425,-0.798,0.0}
};

int [][] patches = {
    {32},
{1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16},
{4,17,18,19,8,20,21,22,12,23,24,25,16,26,27,28},
{19,29,30,31,22,32,33,34,25,35,36,37,28,38,39,40},
{31,41,42,1,34,43,44,5,37,45,46,9,40,47,48,13},
{13,14,15,16,49,50,51,52,53,54,55,56,57,58,59,60},
{16,26,27,28,52,61,62,63,56,64,65,66,60,67,68,69},
{28,38,39,40,63,70,71,72,66,73,74,75,69,76,77,78},
{40,47,48,13,72,79,80,49,75,81,82,53,78,83,84,57},
{57,58,59,60,85,86,87,88,89,90,91,92,93,94,95,96},
{60,67,68,69,88,97,98,99,92,100,101,102,96,103,104,105},
{69,76,77,78,99,106,107,108,102,109,110,111,105,112,113,114},
{78,83,84,57,108,115,116,85,111,117,118,89,114,119,120,93},
{121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136},
{124,137,138,121,128,139,140,125,132,141,142,129,136,143,144,133},
{133,134,135,136,145,146,147,148,149,150,151,152,69,153,154,155},
{136,143,144,133,148,156,157,145,152,158,159,149,155,160,161,69},
{162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177},
{165,178,179,162,169,180,181,166,173,182,183,170,177,184,185,174},
{174,175,176,177,186,187,188,189,190,191,192,193,194,195,196,197},
{177,184,185,174,189,198,199,186,193,200,201,190,197,202,203,194},
{204,204,204,204,207,208,209,210,211,211,211,211,212,213,214,215},
{204,204,204,204,210,217,218,219,211,211,211,211,215,220,221,222},
{204,204,204,204,219,224,225,226,211,211,211,211,222,227,228,229},
{204,204,204,204,226,230,231,207,211,211,211,211,229,232,233,212},
{212,213,214,215,234,235,236,237,238,239,240,241,242,243,244,245},
{215,220,221,222,237,246,247,248,241,249,250,251,245,252,253,254},
{222,227,228,229,248,255,256,257,251,258,259,260,254,261,262,263},
{229,232,233,212,257,264,265,234,260,266,267,238,263,268,269,242},
{270,270,270,270,279,280,281,282,275,276,277,278,271,272,273,274},
{270,270,270,270,282,289,290,291,278,286,287,288,274,283,284,285},
{270,270,270,270,291,298,299,300,288,295,296,297,285,292,293,294},
{270,270,270,270,300,305,306,279,297,303,304,275,294,301,302,271},
{306}
};

More readable version:
void setup() {
  size(640,480,P3D);
}

void draw() {
  background(0);
  noFill();
  stroke(255);
  translate(width/2,height/2,70);
  scale(30);
  rotateX(map(mouseX,0,width,0,TWO_PI));
  rotateY(map(mouseY,0,height,0,TWO_PI));
  for (int[] p:patches) {
    beginShape();
    for (int pt:p) {
      vertex(data[pt-1][0],data[pt-1][2],data[pt-1][2]);
    }
    endShape(CLOSE);
  }
}

And some pics:

Another version with some interesting effects:
void setup(){size(640,480,P3D);}
void draw(){
  background(0);noFill();stroke(255);
  translate(width/2,height/2,70);scale(30);
  rotateX(map(mouseX,0,width,0,TWO_PI));rotateY(map(mouseY,0,height,0,TWO_PI));
  for(int[] p:patches){
    //beginShape(QUADS);
    for(int pt:p){
      for(int pu:p){
        //vertex(data[pu-1][0],data[pu-1][4],data[pu-1][2]);
        line(data[pt-1][0],data[pt-1][5],data[pt-1][2],data[pu-1][0],data[pu-1][6],data[pu-1][2]);
    }}
    //endShape(CLOSE);
  }
}

It should split the patches at least once, I think, for the spout to take shape.

Yes the second picture is better. You're not really doing subdivision, though, it seems. The edges of each patch are Bezier curves... Even so, +1 It looks like a teapot!

stroke(-1) is one byte shorter than stroke(255)

Postscript
Not fully golfed, but this illustrates a different approach than deCasteljau subdivision: evaluating the basis polynomial. Uses mat.ps.
(mat.ps)run[    % load matrix library, begin dictionary construction

/N 17
/C [ 0 7 4 ]   % Cam
/E [ 0 0 40 ] % Eye
/R 0 roty 120 rotx 90 rotz   % Rot: pan tilt twist
          matmul   matmul

/f(teapot)(r)file
/t{token pop exch pop}      % parse a number or other ps token
/s{(,){search not{t exit}if t 3 1 roll}loop}  % parse a comma-separated list
/r{token pop{[f 99 string readline pop s]}repeat}>>begin   % parse a count-prefixed paragraph of csv numbers
[/P[f r]/V[f r]/v{1 sub V exch get}        % Patches and Vertices and vert lookup shortcut
/B[[-1 3 -3 1][3 -6 3 0][-3 3 0 0][1 0 0 0]]              % Bezier basis matrix
/A{dup dup mul exch 2 copy mul 3 1 roll 1 4 array astore} % x->[x^3 x^2 x 1]
/M{[1 index 0 4 getinterval 2 index 4 4 getinterval       % flattened matrix->rowXcolumn matrix
3 index 8 4 getinterval 4 index 12 4 getinterval]exch pop}
/J{ C{sub}vop R matmul 0 get                              % perspective proJection  [x y z]->[X Y]
    aload pop E aload pop
    4 3 roll div exch neg
    4 3 roll add 1 index mul 4 1 roll
    3 1 roll sub mul}
>>begin

300 400 translate
1 14 dup dup scale div currentlinewidth mul setlinewidth  % global scale
/newline { /line {moveto /line {lineto} store} store } def
newline
P{
    8 dict begin
        [exch{v J 2 array astore}forall]/p exch def   % load patch vertices and project to 2D
        /X[p{0 get}forall] M B exch matmul B matmul def  % multiply control points by Bezier basis
        /Y[p{1 get}forall] M B exch matmul B matmul def

        0 1 N div 1 1 index .2 mul add{A/U exch def   % interpolate the polynomial over (u,v)/(N)
            /UX U X matmul def
            /UY U Y matmul def
            0 1 N div 1 1 index .2 mul add{A/V exch 1 array astore transpose def
                /UXV UX V matmul def
                /UYV UY V matmul def
                UXV 0 get 0 get
                UYV 0 get 0 get line
            }for
            newline
        }for

        0 1 N div 1 1 index .2 mul add{A/V exch def   % interpolate the polynomial over (u,v)/(N)
            /V [V] transpose def
            /XV X V matmul def
            /YV Y V matmul def
            0 1 N div 1 1 index .2 mul add{A/U exch 1 array astore transpose def
                /UXV U XV matmul def
                /UYV U YV matmul def
                UXV 0 get 0 get
                UYV 0 get 0 get line
            }for
            newline
        }for

    end

    %exit
}forall
stroke

1112
Stripping out the vertical lines, and discounting the parameters, yields
this 1112 char version. Uses mat.ps.
(mat.ps)run[    % 12

/N 17
/C [ 0 7 4 ]   % Cam
/E [ 0 0 40 ] % Eye
/R 0 roty 120 rotx 90 rotz   % Rot: pan tilt twist
          matmul   matmul

/f(teapot)(r)file/t{token pop exch pop}/s{(,){search not{t exit}if t   % 1100
3 1 roll}loop}/r{token pop{[f 99 string readline pop
s]}repeat}>>begin[/P[f r]/V[f r]/v{1 sub
V exch get}/B[[-1 3 -3 1][3 -6 3 0][-3 3 0 0][1 0 0 0]]/A{dup dup mul exch
2 copy mul 3 1 roll 1 4 array astore}/M{[1 index 0 4 getinterval 2 index 4 4 getinterval
3 index 8 4 getinterval 4 index 12 4 getinterval]exch pop}/J{C{sub}vop R matmul 0 get
aload pop E aload pop 4 3 roll div exch neg 4 3 roll add 1 index mul 4 1 roll
3 1 roll sub mul}>>begin 300 400 translate
1 14 dup dup scale div currentlinewidth mul setlinewidth
/newline{/line{moveto/line{lineto}store}store}def newline
P{8 dict begin[exch{v J 2 array astore}forall]/p
exch def/X[p{0 get}forall] M B exch matmul B matmul
def/Y[p{1 get}forall] M B exch matmul B matmul def
0 1 N div 1 1 index .2 mul add{A/U exch def/UX U X matmul def/UY U Y matmul def
0 1 N div 1 1 index .2 mul add{A/V exch 1 array astore transpose
def/UXV UX V matmul def/UYV UY V matmul def UXV 0 get 0 get UYV 0 get 0 get line}for
newline}for end}forall stroke

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

sort: votes


text:
Program that prints mirror images of it's own self
Write a program that produces mirror images of itself.  An example, would be the fantastic camel code that reads it's own code and produces two smaller 2x2 versions.  Given the input:
                                           $_='ev
                                       al("seek\040D
           ATA,0,                  0;");foreach(1..3)
       {<DATA>;}my               @camel1hump;my$camel;
  my$Camel  ;while(             <DATA>){$_=sprintf("%-6
9s",$_);my@dromedary           1=split(//);if(defined($
_=<DATA>)){@camel1hum        p=split(//);}while(@dromeda
 ry1){my$camel1hump=0      ;my$CAMEL=3;if(defined($_=shif
        t(@dromedary1    ))&&/\S/){$camel1hump+=1<<$CAMEL;}
       $CAMEL--;if(d   efined($_=shift(@dromedary1))&&/\S/){
      $camel1hump+=1  <<$CAMEL;}$CAMEL--;if(defined($_=shift(
     @camel1hump))&&/\S/){$camel1hump+=1<<$CAMEL;}$CAMEL--;if(
     defined($_=shift(@camel1hump))&&/\S/){$camel1hump+=1<<$CAME
     L;;}$camel.=(split(//,"\040..m`{/J\047\134}L^7FX"))[$camel1h
      ump];}$camel.="\n";}@camel1hump=split(/\n/,$camel);foreach(@
      camel1hump){chomp;$Camel=$_;y/LJF7\173\175`\047/\061\062\063\
      064\065\066\067\070/;y/12345678/JL7F\175\173\047`/;$_=reverse;
       print"$_\040$Camel\n";}foreach(@camel1hump){chomp;$Camel=$_;y
        /LJF7\173\175`\047/12345678/;y/12345678/JL7F\175\173\0 47`/;
         $_=reverse;print"\040$_$Camel\n";}';;s/\s*//g;;eval;   eval
           ("seek\040DATA,0,0;");undef$/;$_=<DATA>;s/\s*//g;(   );;s
             ;^.*_;;;map{eval"print\"$_\"";}/.{4}/g; __DATA__   \124
               \1   50\145\040\165\163\145\040\157\1 46\040\1  41\0
                    40\143\141  \155\145\1 54\040\1   51\155\  141
                    \147\145\0  40\151\156 \040\141    \163\16 3\
                     157\143\   151\141\16  4\151\1     57\156
                     \040\167  \151\164\1   50\040\      120\1
                     45\162\   154\040\15    1\163\      040\14
                     1\040\1   64\162\1      41\144       \145\
                     155\14    1\162\       153\04        0\157
                      \146\     040\11     7\047\         122\1
                      45\15      1\154\1  54\171          \040
                      \046\         012\101\16            3\16
                      3\15           7\143\15             1\14
                      1\16            4\145\163           \054
                     \040            \111\156\14         3\056
                    \040\         125\163\145\14         4\040\
                    167\1        51\164\1  50\0         40\160\
                  145\162                              \155\151
                \163\163                                \151\1
              57\156\056

it produces:
        JXXXXXXXXL.       JXXLm.       .mJXXL       .JXXXXXXXXL
       {XXXXXXXXXXX.     JXXXmXXXXm mXXXXmXXXL     .XXXXXXXXXXX}
      .XXXXXXXXXXXXXL.  {XXXXXXXXXF 7XXXXXXXXX}  .JXXXXXXXXXXXXX.
     JXXXXXXXXXXXXXXXXL.`XXXXXX.       .XXXXXX'.JXXXXXXXXXXXXXXXXL
    JXXXXXXXXXXXXXXXXXXXmXXXXXXX.     .XXXXXXXmXXXXXXXXXXXXXXXXXXXL
  .XXXXXXXXXXXXXXXXXXXXXXXXXXXXX}     {XXXXXXXXXXXXXXXXXXXXXXXXXXXXX.
 .XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX       XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX.
 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXF       7XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 XX'7XXXXXXXXXXXXXXXXXXXXXXXXXF         7XXXXXXXXXXXXXXXXXXXXXXXXXF`XX
 XX {XXXFXXXXXXXXXXXXXXXXXXXF'           `7XXXXXXXXXXXXXXXXXXX7XXX} XX
 `X}{XXX'7XXXFXXXXX^XXXXX `'               `' XXXXX^XXXXX7XXXF`XXX}{X'
  `'XXX' {XXX'XXXXX 7XXXF                     7XXXF XXXXX`XXX} `XXX`'
   .XX}  {XXF {XXXX}`XXX}                     {XXX'{XXXX} 7XX}  {XX.
   {XX   `XXL  `7XX} 7XX}                     {XXF {XXF'  JXX'   XX}
   `XX    `XXL mXXF  {XX                       XX}  7XXm JXX'    XX'
    XX      7XXXF    `XX                       XX'    7XXXF      XX
    XX.    JXXXX.     7X.                     .XF     .XXXXL    .XX
   {XXL    7XF7XXX.   {XX                     XX}   .XXXF7XF    JXX}
   `XXX'              `XXXm                 mXXX'              `XXX'
                       ^^^^^               ^^^^^
    .mJXXL       .JXXXXXXXXL                JXXXXXXXXL.       JXXLm.
 mXXXXmXXXL     .XXXXXXXXXXX}              {XXXXXXXXXXX.     JXXXmXXXXm
 7XXXXXXXXX}  .JXXXXXXXXXXXXX.            .XXXXXXXXXXXXXL.  {XXXXXXXXXF
    .XXXXXX'.JXXXXXXXXXXXXXXXXL          JXXXXXXXXXXXXXXXXL.`XXXXXX.
   .XXXXXXXmXXXXXXXXXXXXXXXXXXXL        JXXXXXXXXXXXXXXXXXXXmXXXXXXX.
   {XXXXXXXXXXXXXXXXXXXXXXXXXXXXX.    .XXXXXXXXXXXXXXXXXXXXXXXXXXXXX}
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX.  .XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
    7XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXF
     7XXXXXXXXXXXXXXXXXXXXXXXXXF`XX  XX'7XXXXXXXXXXXXXXXXXXXXXXXXXF
      `7XXXXXXXXXXXXXXXXXXX7XXX} XX  XX {XXXFXXXXXXXXXXXXXXXXXXXF'
        `' XXXXX^XXXXX7XXXF`XXX}{X'  `X}{XXX'7XXXFXXXXX^XXXXX `'
           7XXXF XXXXX`XXX} `XXX`'    `'XXX' {XXX'XXXXX 7XXXF
           {XXX'{XXXX} 7XX}  {XX.      .XX}  {XXF {XXXX}`XXX}
           {XXF {XXF'  JXX'   XX}      {XX   `XXL  `7XX} 7XX}
            XX}  7XXm JXX'    XX'      `XX    `XXL mXXF  {XX
            XX'    7XXXF      XX        XX      7XXXF    `XX
           .XF     .XXXXL    .XX        XX.    JXXXX.     7X.
           XX}   .XXXF7XF    JXX}      {XXL    7XF7XXX.   {XX
         mXXX'              `XXX'      `XXX'              `XXXm
        ^^^^^                                              ^^^^^
The use of a camel image in association with Perl is a trademark of O'Reilly &
Associates, Inc. Used with permission.

(The copyright text is optional.)
A simpler example would take the input:
#######
#
#
######
      #
#     #
 #####

and produce:
 #####      #####
#     #    #     #
      #    #
######      ######
#                #
#                #
#######    #######

#######    #######
#                #
#                #
######      ######
      #    #
#     #    #     #
 #####      #####

The entries should demonstrate art.
This is a popularity contest, so the entry with maximum (up)votes wins!

Is the goal here code which just mirrors text, or does it have to be a proper quine? Should it actually take input or not?

@nitro2k01 It should mirror text; it isn't really expected to be a proper quine.  No user input is expected.

Well your camel 3 and 4 should be upside down to be mirror image of camel 1 and 2 !

@MukulKumar Either form is ok as long as the output is artistic.

I think the title should be changed to "ɟʃǝs uʍo sʇı ɟo sǝƃɐɯı ɹoɹɹıɯ sʇuıɹd ʇɐɥʇ ɯɐɹƃoɹԀ".

@devnull Nice - I only just noticed the bounty on this! :)

@DigitalTrauma As I've mentioned in the bounty message, I felt odd that the answer wasn't really noticed by the community.  Honestly, I didn't even expect that a single answer would address both the challenges in the question.  Your artistic answer without making use of an esoteric language is simply amazing.

Bash and common utils
You may have to install rev
I wasn't satisfied with merely reflecting character positions, it really messes up ascii-art input.  So I tried to reflect characters too, modulo the ascii character set.
#!/bin/bash
half_width=39
left='/(q[{d>Ss'
right='\\)p]}b<Zz'
up='\\`!^qwWtupSs_'
down='/,ivdmMfnbZz\-'
function callback () {
line=${2: 0: half_width}
p=$((half_width-${#line}))
printf "%s%${p}s%${p}s%s\n" \
"$line" "" "" "$(rev<<<"$line" \
| tr $left$right $right$left)" ; }
if ! [ "$1" ]; then cat < "$0"; elif
[ "$1" == "-" ]; then cat; else cat < "$1"
fi | mapfile -c1 -Ccallback -t | tee >(tac | tr $up$down $down$up)

With no arguments, the script prints itself reflected 2x2, as requested:
$ ./2x2.sh
#!/bin/bash                                                        hzad\nid\!#
half_width=39                                                    93=htbiw_flah
left='/(q[{d>Ss'                                              'zZ<b}]p)\'=tfel
right='\\)p]}b<Zz'                                          'sS>d{[q(//'=thgir
up='\\`!^qwWtupSs_'                                        '_zZqutWwp^!`//'=qu
down='/,ivdmMfnbZz\-'                                    '-/sSdnfMmbvi,\'=nwob
function callback () {                                  } () kcadllac noitcnuf
line=${2: 0: half_width}                              {htbiw_flah :0 :2}$=enil
p=$((half_width-${#line}))                          (({enil#}$-htbiw_flah))$=q
printf "%s%${p}s%${p}s%s\n" \                    / "n/z%z{q}$%z{q}$%z%" ftnirq
"$line" "" "" "$(rev<<<"$line" \              / "enil$">>>ver)$" "" "" "enil$"
| tr $left$right $right$left)" ; }          { ; "(tfel$thgir$ thgir$tfel$ rt |
if ! [ "$1" ]; then cat < "$0"; elif      file ;"0$" > tac neht ;[ "1$" ] ! fi
[ "$1" == "-" ]; then cat; else cat < "" > tac ezle ;tac neht ;[ "-" == "1$" ]
fi | mapfile -c1 -Ccallback -t | tee >()< eet | t- kcadllacC- 1c- elifqam | if
t! | wabt!le _c1 _Ccallpack _f | fee >()< eef | f_ kcaqllacC_ 1c_ el!tdaw | !t
[ "$1" == "_" ]; fheu caf; elze caf < "" > fac esle ;fac uehf ;[ "_" == "1$" ]
!t i [ "$1" ]; fheu caf < "$0"; el!t      t!le ;"0$" > fac uehf ;[ "1$" ] i t!
| fr $letf$r!ghf $r!ghf$letf)" ; }          { ; "(ftel$fhg!r$ fhg!r$ftel$ rf |
"$l!ue" "" "" "$(re^<<<"$l!ue" /              \ "eu!l$">>>^er)$" "" "" "eu!l$"
br!uft "%z%${b}z%${b}z%z/u" /                    \ "u\s%s{d}$%s{d}$%s%" tfu!rd
b=$((halt-m!qfh_${#l!ue}))                          (({eu!l#}$_hfp!m-tlah))$=d
l!ue=${2: 0: halt-m!qfh}                              {hfp!m-tlah :0 :2}$=eu!l
tnucf!ou callpack () {                                  } () kcaqllac uo!fcunt
qomu='\`!^qwWtupSs/_'                                    '_\zZqutWwp^!`/'=umop
nb='//,ivdmMfnbZz-'                                        '-sSdnfMmbvi,\\'=dn
r!ghf='//)b]}p<Ss'                                          'zZ>q{[d(\\'=fhg!r
letf='\(d[{q>Zz'                                              'sS<p}]b)/'=ftel
halt-m!qfh=39                                                    93=hfp!m-tlah
#i\p!u\pazh                                                        hsaq/u!q/i#
$

You may also provide in input filename:
$ ./2x2.sh ppcg.fig
 ____  ____   ____ ____                                ____ ____   ____  ____
|  _ \|  _ \ / ___/ ___|                              |___ \___ \ / _  |/ _  |
| |_) | |_) | |  | |  _                                _  | |  | | (_| | (_| |
|  __/|  __/| |__| |_| |                              | |_| |__| |\__  |\__  |
|_|   |_|    \____\____|                              |____/____/    |_|   |_|

|-|   |-|    /----/----|                              |----\----\    |-|   |-|
|  --\|  --\| |--| |-| |                              | |-| |--| |/--  |/--  |
| |-) | |-) | |  | |  -                                -  | |  | | (-| | (-| |
|  - /|  - / \ ---\ ---|                              |--- /--- / \ -  |\ -  |
 ----  ----   ---- ----                                ---- ----   ----  ----
$

If the input filename is -, the script will read input from stdin:
$ cowsay moo | ./2x2.sh -
 _____                                                                  _____
< moo >                                                                < oom >
 -----                                                                  -----
        \   ^__^                                              ^__^   /
         \  (oo)\_______                              _______/(oo)  /
            (__)\       )\/\                      /\/(       /(__)
                ||----w |                            | w----||
                ||     ||                            ||     ||
                ||     ||                            ||     ||
                ||____m |                            | m____||
            (--)/       )/\/                      \/\(       \(--)
         /  (oo)/-------                              -------\(oo)  \
        /   v--v                                              v--v   \
 _____                                                                  _____
< woo >                                                                < oow >
 -----                                                                  -----
$

Amazing!  You did both in one!  Wish I could upvote this n times over.  echo +1 | ./2x2.sh -

@devnull I'm not very good at making the code formatting look pretty, but what I really like is that a back-to-front cow says oom and an upside-down cow says woo

You've made the perfect use of what they call useless use of cat.

@devnull I was tormented about the use of cat here.  I know I could have removed it completely, but that would have meant repeating almost identical mapfile commands 3 times.  I am using "pretty" to justify this use of cat ;-)

Oh! I do understand bash a bit to figure it out :-)  (What I meant by in my previous comment was: cat is damn useful in certain situations)

@devnull agreed - cat has a bad name IMO, and I will shamelessly use it where I think it is appropriate ;-)

Ruby
This one definitely took me a while. But it was really fun!
#
e=
"/+
+d.f
/(.-.
e*0*,+
(*1*e/*
.-.).,*e
/+/(.c.1/
,**-c.e**+
b*,*c+d+++*
*e.+.0/*+b/+
+d/+*e/a.1/(*
0/+*e/*.-/..-/
*/+.-*1*e.d.)/(
*0*.+a.a.f.1.e*1
+b/(/-/,/+*0/+*b/
+*e/*.-/..-/*/+.-*
1";eval e.tr("#{ }
 ",'').split('').
each_slice(?\x2.
ord+0x308333+0+
-3179315).map{
#............
|x|x. join .
tr(  '(-7',
'0-9A-F').
to_i(16).
chr.ord.
chr.ord
.chr.#
chr}*
'' +
''+
''
#

Output:
#                                   #
e=                                 ''
"/+                               ''+
+d.f                             '' +
/(.-.                           chr}*
e*0*,+                         .chr.#
(*1*e/*                       chr.ord
.-.).,*e                     chr.ord.
/+/(.c.1/                   to_i(16).
,**-c.e**+                 '0-9A-F').
b*,*c+d+++*               tr(  '(-7',
*e.+.0/*+b/+             |x|x. join .
+d/+*e/a.1/(*           #............
0/+*e/*.-/..-/         -3179315).map{
*/+.-*1*e.d.)/(       ord+0x308333+0+
*0*.+a.a.f.1.e*1     each_slice(?\x2.
+b/(/-/,/+*0/+*b/    ",'').split('').
+*e/*.-/..-/*/+.-* 1";eval e.tr("#{ }
1";eval e.tr("#{ } +*e/*.-/..-/*/+.-*
 ",'').split('').   +b/(/-/,/+*0/+*b/
each_slice(?\x2.     *0*.+a.a.f.1.e*1
ord+0x308333+0+       */+.-*1*e.d.)/(
-3179315).map{         0/+*e/*.-/..-/
#............           +d/+*e/a.1/(*
|x|x. join .             *e.+.0/*+b/+
tr(  '(-7',               b*,*c+d+++*
'0-9A-F').                 ,**-c.e**+
to_i(16).                   /+/(.c.1/
chr.ord.                     .-.).,*e
chr.ord                       (*1*e/*
.chr.#                         e*0*,+
chr}*                           /(.-.
'' +                             +d.f
''+                               "/+
''                                 e=
#                                   #
#                                   #
''                                 e=
''+                               "/+
'' +                             +d.f
chr}*                           /(.-.
.chr.#                         e*0*,+
chr.ord                       (*1*e/*
chr.ord.                     .-.).,*e
to_i(16).                   /+/(.c.1/
'0-9A-F').                 ,**-c.e**+
tr(  '(-7',               b*,*c+d+++*
|x|x. join .             *e.+.0/*+b/+
#............           +d/+*e/a.1/(*
-3179315).map{         0/+*e/*.-/..-/
ord+0x308333+0+       */+.-*1*e.d.)/(
each_slice(?\x2.     *0*.+a.a.f.1.e*1
 ",'').split('').   +b/(/-/,/+*0/+*b/
1";eval e.tr("#{ } +*e/*.-/..-/*/+.-*
+*e/*.-/..-/*/+.-* 1";eval e.tr("#{ }
+b/(/-/,/+*0/+*b/    ",'').split('').
*0*.+a.a.f.1.e*1     each_slice(?\x2.
*/+.-*1*e.d.)/(       ord+0x308333+0+
0/+*e/*.-/..-/         -3179315).map{
+d/+*e/a.1/(*           #............
*e.+.0/*+b/+             |x|x. join .
b*,*c+d+++*               tr(  '(-7',
,**-c.e**+                 '0-9A-F').
/+/(.c.1/                   to_i(16).
.-.).,*e                     chr.ord.
(*1*e/*                       chr.ord
e*0*,+                         .chr.#
/(.-.                           chr}*
+d.f                             '' +
"/+                               ''+
e=                                 ''
#                                   #

It's based on the same idea as my previous answer.

Aha! this is extremely pretty.

Ruby
UPDATE: Check out my new answer, based on the same idea as this one!
$,                                    |
   e="s=  open(  $0).r  ead.s  pli    |
   t   (  1   0  .      ch     r);    |
   $   ,  =   3  2      .      chr    |
   ;s=s.  zip(s  .      r ev   ers    |
   e      )      .      m   a         |
   p      (      &:joi  n);pu   t     |
                                      |
s(s+s.reverse)";eval e.gsub(/[\s|]/,'')

Output:
$,                                    | s(s+s.reverse)";eval e.gsub(/[\s|]/,'')
   e="s=  open(  $0).r  ead.s  pli    |                                       |
   t   (  1   0  .      ch     r);    |    p      (      &:joi  n);pu   t     |
   $   ,  =   3  2      .      chr    |    e      )      .      m   a         |
   ;s=s.  zip(s  .      r ev   ers    |    ;s=s.  zip(s  .      r ev   ers    |
   e      )      .      m   a         |    $   ,  =   3  2      .      chr    |
   p      (      &:joi  n);pu   t     |    t   (  1   0  .      ch     r);    |
                                      |    e="s=  open(  $0).r  ead.s  pli    |
s(s+s.reverse)";eval e.gsub(/[\s|]/,'') $,                                    |
s(s+s.reverse)";eval e.gsub(/[\s|]/,'') $,                                    |
                                      |    e="s=  open(  $0).r  ead.s  pli    |
   p      (      &:joi  n);pu   t     |    t   (  1   0  .      ch     r);    |
   e      )      .      m   a         |    $   ,  =   3  2      .      chr    |
   ;s=s.  zip(s  .      r ev   ers    |    ;s=s.  zip(s  .      r ev   ers    |
   $   ,  =   3  2      .      chr    |    e      )      .      m   a         |
   t   (  1   0  .      ch     r);    |    p      (      &:joi  n);pu   t     |
   e="s=  open(  $0).r  ead.s  pli    |                                       |
$,                                    | s(s+s.reverse)";eval e.gsub(/[\s|]/,'')

It's "PPCG!" in ASCII art! :D
Here's a detailed explanation. First, I found out how to do the actual mirroring. Here's the mirroring code:
s = open($0).read.split "\n"
$, = ' '
s = s.zip(s.reverse).map &:join
puts s + s.reverse

Then I had to remove whitespace characters and double quotes (because escaping just gets messy), so I used Ruby's Fixnum#chr.
The basic structure of the program is now:
e="<code>"
eval e.gsub(/\s/,'')

Now I can make it into ASCII art! So, that's what I did. Then, I padded the ASCII art with spaces and |s at the end, and I made it to here:
e="s=  open(  $0).r  ead.s  pli       |
t   (  1   0  .      ch     r);       |
$   ,  =   3  2      .      chr       |
;s=s.  zip(s  .      r ev   ers       |
e      )      .      m   a            |
p      (      &:joi  n);pu   t        |
s(s+s.reverse)";eval e.gsub(/[\s|]/,'')

However, that looked a bit ugly, since there wasn't enough padding around the ASCII art. Therefore, I added a bit of extra padding, and got where I am now! ($, | x is equivalent to x since $, is nil by default.)

This is artistic!

Didn't notice the evil eval earlier :)

bash ( + sed  + tee + tac ) -> 102
sed -re 'h;s/$/\o1/;:a;s/(.)\o1(.*)$/\o1\2\1/;ta;s/^\o1//;G;s/^(.*)\n(.*)$/\2 \1/' ${1:-$0}|tee >(tac)

Sample useable
#!/bin/bash

sed -re 'h;s/$/\o1/;:a;s/(.)\o1(.*)$/\o1\2\1/;ta;
         s/^\o1//;G;s/^(.*)\n(.*)$/\2 \1/' ${1:-$0} |
    tee >(tac)

Sample detailed:
#!/bin/bash

sed -re '
    h;         # copy current line to hold space
    s/$/\o1/;  # add chr(1) at end of line
   :a;         # branch label for further goto
    s/(.)\o1(.*)$/\o1\2\1/; # move 1 char at end to end
    ta;        # goto :a if previous `s///` do match
    s/^\o1//;  # drop chr(1)
    G;         # Append newline + hold space to current line
    s/^(.*)\n(.*)$/\2 \1/ # Suppress newline and swap line <-> hold space
' ${1:-$0} |   # From file as first arg or script himself, than pipe  to
    tee >(     # tee would double stdout and pass feed to
      tac )    # tac as reverse cat.

This could result as:
./revmir.sh
#!/bin/bash hsab/nib/!#

sed -re ' ' er- des
    h;         # copy current line to hold space ecaps dloh ot enil tnerruc ypoc #         ;h
    s/$/\o1/;  # add chr(1) at end of line enil fo dne ta )1(rhc dda #  ;/1o\/$/s
   :a;         # branch label for further goto otog rehtruf rof lebal hcnarb #         ;a:
    s/(.)\o1(.*)$/\o1\2\1/; # move 1 char at end to end dne ot dne ta rahc 1 evom # ;/1\2\1o\/$)*.(1o\).(/s
    ta;        # goto :a if previous `s///` do match hctam od `///s` suoiverp fi a: otog #        ;at
    s/^\o1//;  # drop chr(1) )1(rhc pord #  ;//1o\^/s
    G;         # Append newline + hold space to current line enil tnerruc ot ecaps dloh + enilwen dneppA #         ;G
    s/^(.*)\n(.*)$/\2 \1/ # Suppress newline and swap line <-> hold space ecaps dloh >-< enil paws dna enilwen sserppuS # /1\ 2\/$)*.(n\)*.(^/s
' ${1:-$0} |   # From file as first arg or script himself, than pipe  to ot  epip naht ,flesmih tpircs ro gra tsrif sa elif morF #   | }0$-:1{$ '
    tee >(     # tee would double stdout and pass feed to ot deef ssap dna tuodts elbuod dluow eet #     (> eet
      tac )    # tac as reverse cat. .tac esrever sa cat #    ) cat

      tac )    # tac as reverse cat. .tac esrever sa cat #    ) cat
    tee >(     # tee would double stdout and pass feed to ot deef ssap dna tuodts elbuod dluow eet #     (> eet
' ${1:-$0} |   # From file as first arg or script himself, than pipe  to ot  epip naht ,flesmih tpircs ro gra tsrif sa elif morF #   | }0$-:1{$ '
    s/^(.*)\n(.*)$/\2 \1/ # Suppress newline and swap line <-> hold space ecaps dloh >-< enil paws dna enilwen sserppuS # /1\ 2\/$)*.(n\)*.(^/s
    G;         # Append newline + hold space to current line enil tnerruc ot ecaps dloh + enilwen dneppA #         ;G
    s/^\o1//;  # drop chr(1) )1(rhc pord #  ;//1o\^/s
    ta;        # goto :a if previous `s///` do match hctam od `///s` suoiverp fi a: otog #        ;at
    s/(.)\o1(.*)$/\o1\2\1/; # move 1 char at end to end dne ot dne ta rahc 1 evom # ;/1\2\1o\/$)*.(1o\).(/s
   :a;         # branch label for further goto otog rehtruf rof lebal hcnarb #         ;a:
    s/$/\o1/;  # add chr(1) at end of line enil fo dne ta )1(rhc dda #  ;/1o\/$/s
    h;         # copy current line to hold space ecaps dloh ot enil tnerruc ypoc #         ;h
sed -re ' ' er- des

#!/bin/bash hsab/nib/!#

or formated to fixed line width:
printf -v spc '%74s';sed "s/\$/$spc/;s/^\(.\{74\}\) *$/\1/" <revmir.sh | ./revmir.sh -

give:
#!/bin/bash                                                                                hsab/nib/!#

sed -re '                                                                                ' er- des
    h;         # copy current line to hold space                                                     ecaps dloh ot enil tnerruc ypoc #         ;h
    s/$/\o1/;  # add chr(1) at end of line                                                                 enil fo dne ta )1(rhc dda #  ;/1o\/$/s
   :a;         # branch label for further goto                                                         otog rehtruf rof lebal hcnarb #         ;a:
    s/(.)\o1(.*)$/\o1\2\1/; # move 1 char at end to end                                       dne ot dne ta rahc 1 evom # ;/1\2\1o\/$)*.(1o\).(/s
    ta;        # goto :a if previous `s///` do match                                             hctam od `///s` suoiverp fi a: otog #        ;at
    s/^\o1//;  # drop chr(1)                                                                                )1(rhc pord #  ;//1o\^/s
    G;         # Append newline + hold space to current line                             enil tnerruc ot ecaps dloh + enilwen dneppA #         ;G
    s/^(.*)\n(.*)$/\2 \1/ # Suppress newline and swap line <-> hold space   ecaps dloh >-< enil paws dna enilwen sserppuS # /1\ 2\/$)*.(n\)*.(^/s
' ${1:-$0} |   # From file as first arg or script himself, than pipe  to     ot  epip naht ,flesmih tpircs ro gra tsrif sa elif morF #   | }0$-:1{$ '
    tee >(     # tee would double stdout and pass feed to                                   ot deef ssap dna tuodts elbuod dluow eet #     (> eet
      tac )    # tac as reverse cat.                                                                             .tac esrever sa cat #    ) cat

      tac )    # tac as reverse cat.                                                                             .tac esrever sa cat #    ) cat
    tee >(     # tee would double stdout and pass feed to                                   ot deef ssap dna tuodts elbuod dluow eet #     (> eet
' ${1:-$0} |   # From file as first arg or script himself, than pipe  to     ot  epip naht ,flesmih tpircs ro gra tsrif sa elif morF #   | }0$-:1{$ '
    s/^(.*)\n(.*)$/\2 \1/ # Suppress newline and swap line <-> hold space   ecaps dloh >-< enil paws dna enilwen sserppuS # /1\ 2\/$)*.(n\)*.(^/s
    G;         # Append newline + hold space to current line                             enil tnerruc ot ecaps dloh + enilwen dneppA #         ;G
    s/^\o1//;  # drop chr(1)                                                                                )1(rhc pord #  ;//1o\^/s
    ta;        # goto :a if previous `s///` do match                                             hctam od `///s` suoiverp fi a: otog #        ;at
    s/(.)\o1(.*)$/\o1\2\1/; # move 1 char at end to end                                       dne ot dne ta rahc 1 evom # ;/1\2\1o\/$)*.(1o\).(/s
   :a;         # branch label for further goto                                                         otog rehtruf rof lebal hcnarb #         ;a:
    s/$/\o1/;  # add chr(1) at end of line                                                                 enil fo dne ta )1(rhc dda #  ;/1o\/$/s
    h;         # copy current line to hold space                                                     ecaps dloh ot enil tnerruc ypoc #         ;h
sed -re '                                                                                ' er- des

#!/bin/bash                                                                                hsab/nib/!#

and using figlet:
figlet -f banner 5 | ./revmir.sh -
#######   #######
#               #
#               #
######     ######
      #   #
#     #   #     #
 #####     #####

 #####     #####
#     #   #     #
      #   #
######     ######
#               #
#               #
#######   #######

And for fun:
figlet -f banner Code Golf. | ./asciiReduce |  ./revmir.sh -
▞▀▀▖▗▄▖▗▄▄ ▄▄▄  ▞▀▀▖▗▄▖▗   ▄▄▄       ▄▄▄   ▗▖▄▗▖▀▀▞  ▄▄▄ ▄▄▗▖▄▗▖▀▀▞
▌   ▌ ▐▐  ▌▙▄▖  ▌▗▄▖▌ ▐▐   ▙▄▖       ▖▄▙   ▐▐ ▌▖▄▗▌  ▖▄▙▌  ▐▐ ▌   ▌
▌  ▖▌ ▐▐  ▌▌    ▌  ▌▌ ▐▐   ▌  ▐█   █▐  ▌   ▐▐ ▌▌  ▌    ▌▌  ▐▐ ▌▖  ▌
▝▀▀ ▝▀▘▝▀▀ ▀▀▀  ▝▀▀ ▝▀▘▝▀▀▘▘  ▝▀   ▀▝  ▘▘▀▀▝▘▀▝ ▀▀▝  ▀▀▀ ▀▀▝▘▀▝ ▀▀▝

▝▀▀ ▝▀▘▝▀▀ ▀▀▀  ▝▀▀ ▝▀▘▝▀▀▘▘  ▝▀   ▀▝  ▘▘▀▀▝▘▀▝ ▀▀▝  ▀▀▀ ▀▀▝▘▀▝ ▀▀▝
▌  ▖▌ ▐▐  ▌▌    ▌  ▌▌ ▐▐   ▌  ▐█   █▐  ▌   ▐▐ ▌▌  ▌    ▌▌  ▐▐ ▌▖  ▌
▌   ▌ ▐▐  ▌▙▄▖  ▌▗▄▖▌ ▐▐   ▙▄▖       ▖▄▙   ▐▐ ▌▖▄▗▌  ▖▄▙▌  ▐▐ ▌   ▌
▞▀▀▖▗▄▖▗▄▄ ▄▄▄  ▞▀▀▖▗▄▖▗   ▄▄▄       ▄▄▄   ▗▖▄▗▖▀▀▞  ▄▄▄ ▄▄▗▖▄▗▖▀▀▞

He, he... This could not work because of half-chars could not be simply reversed.
For this, we have to run command in reversed order:
figlet -f banner Code Golf. |  ./revmir.sh - | asciiReduce
▞▀▀▖▗▄▖▗▄▄ ▄▄▄  ▞▀▀▖▗▄▖▗   ▄▄▄     ▗▄▄▖  ▗ ▄▄ ▞▀▀▖ ▗▄▄▖▗▄▄ ▄▄ ▞▀▀▖
▌   ▌ ▐▐  ▌▙▄▖  ▌▗▄▖▌ ▐▐   ▙▄▖      ▄▄▌  ▐▐  ▌▄▄ ▌  ▄▄▌▌ ▐▐  ▌   ▌
▌  ▖▌ ▐▐  ▌▌    ▌  ▌▌ ▐▐   ▌  ▐█ ▐█   ▌  ▐▐  ▌▌  ▌    ▌▌ ▐▐  ▌▖  ▌
▝▀▀ ▝▀▘▝▀▀ ▀▀▀  ▝▀▀ ▝▀▘▝▀▀▘▘  ▝▀ ▝▀   ▘▀▀▀ ▀▀ ▝▀▀  ▝▀▀▘▝▀▀ ▀▀ ▝▀▀
▗▄▄ ▗▄▖▗▄▄ ▄▄▄  ▗▄▄ ▗▄▖▗▄▄▖▖  ▗▄ ▗▄   ▖▄▄▄ ▄▄ ▗▄▄  ▗▄▄▖▗▄▄ ▄▄ ▗▄▄
▌  ▘▌ ▐▐  ▌▌    ▌  ▌▌ ▐▐   ▌  ▐█ ▐█   ▌  ▐▐  ▌▌  ▌    ▌▌ ▐▐  ▌▘  ▌
▌   ▌ ▐▐  ▌▛▀▘  ▌▝▀▘▌ ▐▐   ▛▀▘      ▀▀▌  ▐▐  ▌▀▀ ▌  ▀▀▌▌ ▐▐  ▌   ▌
▚▄▄▘▝▀▘▝▀▀ ▀▀▀  ▚▄▄▘▝▀▘▝   ▀▀▀     ▝▀▀▘  ▝ ▀▀ ▚▄▄▘ ▝▀▀▘▝▀▀ ▀▀ ▚▄▄▘

Is this '▝' intentional  or means unknown character ?

Still can't understand that ;(

+1.  My guess for the downvote is your first example output doesn't do the padding, and the downvoter didn't bother reading further.  I see you go on to implement padding, so personally I would edit the answer just to include that.

C++
#include<iostream>
int main()
{
    char mirror[]={ 218,196,196,196,196,196,191,
                    218,196,196,196,196,196,191,'\n',
                    179,201,205,203,205,187,179,
                    179,201,205,203,205,187,179,'\n',
                    179,186,254,186,254,186,179,
                    179,186,254,186,254,186,179,'\n',
                    179,204,205,206,205,185,179,
                    179,204,205,206,205,185,179,'\n',
                    179,186,254,186,254,186,179,
                    179,186,254,186,254,186,179,'\n',
                    179,200,205,202,205,188,179,
                    179,200,205,202,205,188,179,'\n',
                    192,196,196,196,196,196,217,
                    192,196,196,196,196,196,217,'\n',
                    '\0'};
    std::cout<<mirror<<mirror;
    getch();
    return 0;
}

output
This output looks like "Windows 4X4".

No one likes my post ... T_T why ?

Maybe because it hardcodes (!) the output in CP-437 (!)? Also it's only an hour old.

@mniip doorknob's post is only 12 minutes old!

I don't know why, but people vote for the high-rep users quicker.  I will vote for you as soon as I get my voting power back.

How is this a mirrored image of the source code? It looks completely different

@TomDoodler do we have to make mirror images of the code?


text:
Random without Time-Basis
Computers do not out-of-nowhere create random numbers without basis, as most likely, time is the universal basis of randomness.
I want you to create a code that creates random numbers with these rules:

Time is not allowed to be the basis, at any point of the program.
Predefined random/pseudo-random functions are not allowed.
Numbers generated can be within any range. Well at least two different integers :D
Numbers are echoed.

It is unclear what you mean by "Numbers generated can be within any range". Do you mean the coder is free to choose a range? Or that they must support any range the user requests?  Both of these are problematic. If the user requests a range, what if they request numbers outside the bounds of the built in data types?  And if the coder is free to choose, I choose integers between 1 and 1.  :D

Should have been a code-golf...

I started this question as popularity-question, would code-golf a better fit for this?

@Daniel Yeah but let this question be popularity-question and post a new question with code golf with new rules(on random generation) that'll be fun

"pseudo-random functions are not allowed." Most if not all of the answers use pseudorandom generation. This rule seems a little useless.

Predefined pseudo-random functions are not allowed - ie calling Random.nextInt() or reading /dev/random. In that the task is to create random numbers, any answer is itself a pseudo-random function.

using the internet as a seed seems like cheating doesn't it?

yup, but i forgot to make a rule for it, there's an answer who just used the local network...

JavaScript
That was fun!
arr = []
index = 0

function init(seed) {
    index = 0
    arr[0] = seed
    for (var i = 1; i < 624; i ++) {
        arr[i] = (1812433253 * (arr[i-1] ^ (arr[i-1] >>> 30)) + i) | 0
    }
 }

function getNumber() {
    if (index == 0) generateNumbers()

    var y = arr[index]
    y ^= (y >>> 11)
    y ^= ((y << 7) & 2636928640)
    y ^= ((y << 15) & 4022730752)
    y ^= (y >>> 18)

    index = (index + 1) % 624
    return y
}

function generateNumbers() {
    for (var i = 0; i < 624; i ++) {
        var y = (arr[i] & 0x80000000) + (arr[(i+1) % 624] & 0x7fffffff)
        arr[i] = arr[(i + 397) % 624] ^ (y >>> 1)
        if (y % 2 != 0) arr[i] ^= 2567483615
    }
}

// let's get our seed now from the SE API
var x = new XMLHttpRequest()
x.open('GET', 'http://api.stackexchange.com/2.2/answers?pagesize=10&order=desc&sort=activity&site=stackoverflow&filter=!Sri2UzKb5mTfr.XgjE', false)
x.send(null)
// we've got the answer data, now just add up all the numbers.
// only 4 digits at a time to prevent too big of a number.
var seed = 0
var numbers = x.responseText.match(/\d{0,4}/g)
for (var i = 0; i < numbers.length; i++) seed += +numbers[i]

init(seed)
for (var i = 0; i < 10; i++) console.log(getNumber())

I wrote up the Mersenne Twister in JS. Then, I realized I had to get a seed from somewhere.
So, I decided I would get it from the Stack Exchange API! (I could use localStorage and increment a counter, but that's no fun.) So, I grabbed the 10 most recently active answers, and then I just took every 4 or less consecutive digits in the response and added them up.
These seeds are always different, since Stack Overflow is constantly updating (and my quota keeps going down!) The numbers include answer IDs, question IDs, scores, up/downvote counts, owner rep/IDs, and the wrapper data (quota and such). On one run I got 256845, then 270495, and then 256048, etc....
This logs 10 random 32-bit two's-complement numbers to the console. Sample output:
247701962
-601555287
1363363842
-1184801866
1761791937
-163544156
2021774189
2140443959
1764173996
-1176627822

C
Compile with the -pthread flag (or whatever your compiler uses).
#include <stdio.h>
#include <pthread.h>

#define m (unsigned long)2147483647
#define q (unsigned long)127773
#define a (unsigned int)16807
#define r (unsigned int)2836

static unsigned long seed;
pthread_t t[20];
int lo, hi, done;

void *pseudorandom(void *id)
{
    while(done)
    {
        int test;
        hi = seed/q;
        lo = seed%q;
        test = a * lo - r * hi;
        if (test > 0) seed = test;
        else seed = test + m;
    }
}

main()
{
     int i;
     seed = 54321;
     done = 1;

     for(i = 0; i < 20; i++)
     {
          pthread_create(&(t[i]), NULL, &pseudorandom, NULL);
     }

     for (i = 0; i < 10; i++)
     {
          printf("%lu\n", seed);
     }

     done = 0;
}

I'm not sure if this qualifies or not based on the "time is not allowed" standard, because it is basically using the scheduler as the source of entropy by intentionally ignoring thread safety. It works by using a fairly basic psuedo-random function (Lehmer random number generator) with a hard coded initial seed.  It then starts 20 threads that all run the Lehmer calculation with a shared set of variables.
Seems to work fairly well, here are a couple of consecutive runs:
comintern ~ $ ./a.out
821551271
198866223
670412515
4292256
561301260
1256197345
959764614
874838892
1375885882
1788849800
comintern ~ $ ./a.out
2067099631
953349057
1736873858
267798474
941322622
564797842
157852857
1263164394
399068484
2077423336

EDIT:
Gave this a little more thought and realized that this isn't time based at all.  Even with a completely deterministic scheduler, the entropy isn't coming from the time slices - it is coming from the loading of all the running processes on the system.
EDIT 2
After taking some inspiration from @Quincunx posting a bell curve, I dumped 12MB of randomness into a file and uploaded it to CAcert. It failed all of the diehard tests, but clocked a respectable 7.999573 out of 8 on the ENT test (only Potentially deterministic). Curiously, doubling the thread count made it worse.

Java
import java.util.Random;
import java.util.concurrent.atomic.AtomicLong;

/**
 *
 * @author Quincunx
 */
public class NoTimeRandom extends Random {

    private AtomicLong seed;

    public NoTimeRandom() {
        byte[] ba = (new String[0].toString() + new String[0].toString()
                + new String[0].toString() + new String[0].toString()
                + new String[0].toString() + new String[0].toString()).getBytes();
        int seed1 = 1;
        for (byte b : ba) {
            seed1 += b;
        }

        ba = (new String[0].toString() + new String[0].toString()
                + new String[0].toString() + new String[0].toString()
                + new String[0].toString() + new String[0].toString()).getBytes();
        long seed2 = 1;
        for (byte b : ba) {
            seed2 += b;
        }

        seed = new AtomicLong(seed1 ^ seed2);
    }

    @Override
    protected int next(int bits) {
        long oldseed, newseed;
        AtomicLong seed = this.seed;
        do {
            oldseed = seed.get();
            newseed = (oldseed * 25214903917L + 11) & 281474976710655L;
        } while (!seed.compareAndSet(oldseed, newseed));

        return (int) (newseed >>> (48 - bits));
    }

    public static void main(String[] args) {
        Random r = new NoTimeRandom();

        for (int i = 0; i < 5; i++) {
            System.out.println(r.nextInt());
        }
    }

}

The magic is in the public NoTimeRandom(). Arrays cast to strings can confuse new programmers, as the numbers are random. Sample (for char[]: [C@4a8e91eb). The next method is copied from java.util.Random.
Sample output:
134277366
467041052
-555611140
-1741034686
1420784423

Let's test the effectiveness of this rng:
In my answer to Approximate a Bell Curve, the data generation I used depends on a good rng. Let's run it with this as the rng. Output:

Just as I thought. This is a pretty lousy rng.

C
It generates a random number in the 0-255 range by taking the seed from https://stackoverflow.com/questions using wget.
#include <stdio.h>
main()
{
    FILE *file;
    unsigned char c,x;
    system("wget -O - https://stackoverflow.com/questions > quest.html");
    file = fopen ("quest.html", "r");
    while(c=fgetc(file) != EOF) x+=c;
    fclose(file);
    printf("%d",x);
}

Sample run:
C:\Users\izabera>random
--2014-03-02 16:15:28--  https://stackoverflow.com/questions
Resolving stackoverflow.com... 198.252.206.140
Connecting to stackoverflow.com|198.252.206.140|:80... connected.
HTTP request sent, awaiting response... 200 OK
Length: 85775 (84K) [text/html]
Saving to: `STDOUT'

100%[======================================>] 85,775      40.3K/s   in 2.1s

2014-03-02 16:15:31 (40.3 KB/s) - `-' saved [85775/85775]

15 /* <=================== THIS IS THE RANDOM NUMBER */
C:\Users\izabera>random
--2014-03-02 16:15:36--  https://stackoverflow.com/questions
Resolving stackoverflow.com... 198.252.206.140
Connecting to stackoverflow.com|198.252.206.140|:80... connected.
HTTP request sent, awaiting response... 200 OK
Length: 85836 (84K) [text/html]
Saving to: `STDOUT'

100%[======================================>] 85,836      50.0K/s   in 1.7s

2014-03-02 16:15:38 (50.0 KB/s) - `-' saved [85836/85836]

76
C:\Users\izabera>random
--2014-03-02 16:15:56--  https://stackoverflow.com/questions
Resolving stackoverflow.com... 198.252.206.140
Connecting to stackoverflow.com|198.252.206.140|:80... connected.
HTTP request sent, awaiting response... 200 OK
Length: 85244 (83K) [text/html]
Saving to: `STDOUT'

100%[======================================>] 85,244      36.0K/s   in 2.3s

2014-03-02 16:15:59 (36.0 KB/s) - `-' saved [85244/85244]

144

perl
What's all this rubbish with getting seeds over the internet? Sounds like cheating to me ;-) I prefer to give my seed to a cryptographic hash function instead, and give output in the range 0 to 2^160-1 like so:
use Digest::SHA1 qw(sha1);
use bigint;
sub r {
  $_ = \3;
  /^.*x([0-9a-f]+).$/;
  hex((unpack "H*", sha1 "some_salt".$1.$$)[0])
}
print join " ", r'

Anytime you have entropy of uncertain quality, a way to distribute it more regularly (but not increase its quality!) is to pipe it into the likes of SHA1 or MD5 or so, as I've done here. For pre-hash seeds, I've used pid and the address of a random reference. You could of course add other inputs for more entropy, eg on x86 you can use TSC - (but inlining assembly code in perl is a bit of a bear, so I skipped it).
If you want to have different output than the guy on the next computer over, simply adjust "some_salt" to be a string of your liking. Or leave it out altogether if you are a minimalist =)

I'd guess that any cryptographic function worth its name in a standard library uses a cryptographically secure RNG internally.

I'm not sure about that. Digest::MD5 / Digest::SHA1 produce completely deterministic, repeatable output, so what does it need a random number for?

Sorry! I just flew over your answer and thought that you were generating a key instead of a digest.

Java
My solution abuses hashCode() method of Object class.
class G22640 {
    static class Rand {
        public int nextInt() {
            return new Object().hashCode();
        }
    }

    public static void main(String args[]) {
        Rand r = new Rand();
        for (int i = 0; i < 10; i++) {
            System.out.println(r.nextInt());
        }
    }
}

Sample output:
31859448
22101035
11593610
4580332
25736626
32157998
3804398
32440180
19905449
2772678

Motivated by other answer's demonstrating the randomness of the solution, I changed my solution to return the middle 16 bits of the int returned by Object.hashCode().
import java.io.*;

class G22640 {
    static class Rand {
        public short nextShort() {
            return (short) ((new Object().hashCode() >> 8) & 0xFFFF);
        }
    }

    public static void main(String args[]) throws IOException {
        Rand r = new Rand();

        for (int i = 0; i < 10; i++) {
            System.out.println(r.nextShort());
        }

        // generateToFile("random_22640.txt");
    }

    private static void generateToFile(String fileName) throws IOException {
        Rand r = new Rand();
        BufferedOutputStream o = new BufferedOutputStream(new FileOutputStream(fileName));

        for (int i = 0; i < 10000000; i++) {
            int a = r.nextShort();
            for (int j = 0; j < 2; j++) {
                o.write(a & 0xFF);
                a >>= 8;
            }
        }

        o.flush();
        o.close();
    }
}

I generated a 19 MB file (consisting of 107 short) and submit it to CACert. Here is the screenshot of the result (it has been edited to look nice, but the numbers are left as it is):

I was surprised at the result, since it clocks 7.999991 at Entropy test and passes (?) all 7 Diehard tests.

C++
#include<iostream>
int main()
{
    int *ptr=new int,i=0;
    for(;i<5;i++)
    {
        std::cout<<*(ptr+i)<<'\n';
    }
    return 0;
}

output
any 5 random numbers
three samples

1st, 2nd and 5th are pretty close, same pattern repeated in all 3 examples. not exactly the expected output from a random number generator.

@izabera When it comes to pointers in generating random numbers...everything depends on your computer(the RAM and processor) maybe the address fed by 'new int' into 'ptr' is being currently used!  You tried to running this code ?

Let me add a little change

i tried it now, on my machine it seems like i always get things like 11230576, 0, 11206992, 0, 2053725299, which still doesn't seem random to me.

check it out at ideone

Javascript
Generating random with user mouse move
var ranArr=[];
var random=0;
var first=second=0;
function generateR(event) {
ranArr.push(parseFloat(event.clientX+document.body.scrollLeft))
ranArr.push(parseFloat(event.clientY+document.body.scrollTop));
var len=ranArr.length;

for(var i=0;i<len;i++) {
    if(i<len/2) {

    first+=ranArr[i];
    } else {
    second += ranArr[i];
    }
}
third = second/first;
third = third+"";
console.log(third.substr(5));
}
document.onmousemove=function(event){generateR(event)};

Last five copied data:
9637090187003
7828470680762
6045869361238
4220720695015
2422653391073

Bash, range: ints between 0 and 1
echo -n & echo "$! % 2" | bc

So you mean it picks 0 or 1 only?

Yep. Should fulfill "Numbers generated can be within any range. Well at least two different integers :D", shouldn‘t it?

I guess so.  Do you think you could expand it to a bigger range?

Just echo -n & echo $! will do, but be a very bad RNG. You can also change 2 with any other number, but the bigger the number, the worse gets the "randomness".

I see.  Thanks for the explanation.

Ruby
Unfortunately Mac only.  We use sox to pull bytes from the microphone (as a string, ahem...), reverse it to get the status header on the end (*cough*), chop it up, chop off the header, take the MD5 of the chunks, ditch the non-numeric chars from the hash, add the remaining largish integers together, stick a 0. on the front, convert to a float, done.
Generates floats of varying length on the interval 0..1.
require 'open3'
require 'digest'

class InsecureRandom
  def self.random_number
    n = self.get_bytes
    .map! { |r| Digest::MD5.hexdigest(r) }
    .map! { |r| r.gsub(/[a-z]/, '') }
    .map!(&:to_i)
    .reduce(0,:+)

    "0.#{n}".to_f
  end

  private
  def self.get_bytes
    Open3.popen3('sox -d -q -e unsigned-integer -p') do |_, stdout, _|
      stdout.read(20000).reverse.split('\\').to_a.take(20)
    end
  end
end

randomish = Array.new(20) { InsecureRandom.random_number }
puts randomish
# >> 0.2333530765409607
# >> 0.17754047429753905
# >> 0.936039801228352
# >> 0.2781141892158962
# >> 0.6243140263525706
# >> 0.1583419168189452
# >> 0.2173713056635174
# >> 0.930577106355
# >> 0.11215268787922089
# >> 0.13292311877287152
# >> 0.14791818448435443
# >> 0.4864648362730452
# >> 0.5133193113765809
# >> 0.3076637743531015
# >> 0.16060112015793476
# >> 0.7294970251624926
# >> 0.18945368886946876
# >> 0.9970215825154781
# >> 0.13775531752383308
# >> 0.5794383903900283

C
Generating random using process ID.
#include <unistd.h>
#include <stdio.h>

int     main(void)
{
    int out;
    out *= out *= out = getpid();
    printf("%d\n", out % 1024);
    return (0);
}

Sample output :
-767
0
769
-1008
337
-768
369
-752
-415
0
-863
784
-463
256
657

SPIN
If this was code-golf, i would win!
byte a
?a@

perl
I saw a lot of answers which made HTTP requests, which seems wasteful to me because under the covers there are random numbers being passed about on the wire. So I decided to write some code to swipe one at a lower level:
use IO::Socket::INET;
print ((sockaddr_in(getsockname(IO::Socket::INET->new(
    PeerAddr => "google.com", PeerPort => 80, Proto => "tcp"
))))[0]);

Gives random ports in the range 0..65535, theoretically. In practice, there are a number of ports you will never see, so the distribution is far from perfect. But it is, AFAICT the minimal amount of work you can do to get some entropy from a remote host that has a port open.
PS - Error handling is left as an exercise to the reader ;-)

C
// alternating two pure-RNG inspired by http://xkcd.com/221/
int getRandomNumber()
{
   static int dice_roll = 0;
   dice_roll++;
   if ((dice_roll % 2) == 1)
   {
      return 4;
   }
   else
   {
      return 5;
   }
}

int main(int argc, char **argv)
{
    printf("%d\n%d\n", getRandomNumber(), getRandomNumber())
    return 0;
}

python
Python's conciseness never ceases to amaze. Since using imgur's random image is not valid apparently, I've used a great source of randomness: stackoverflow's chat!
   import urllib.request

def getrand():
    req = urllib.request.Request("http://chat.stackoverflow.com/")
    response = urllib.request.urlopen(req)
    the_page = str(response.read())

    x = 1
    for char in the_page:
        x = (3*x + ord(char) + 1)%2**32

    print(x)

5 trials:
3258789746
1899058937
3811869909
274739242
1292809118

Not truly random but then again none of these are.

i think rule 2 doesn't allow urls like whatever.com/random

@izabera 2 of the other answers used it?

nope, you're explicitly using randomly generated content. the other answers just access to some non-random webpage to get a seed and then print a random number.

@izabera I've changed my random source. What do you think of it now?

now it's fine :D