Reglas:

• Cualquier idioma que elija (Bibliotecas estándar).
• La salida se muestra en el Terminal o el Procesador de comandos de Windows o de cualquier otra forma que prefiera
  (ancho de búfer = 80)
• Los caracteres ASCII son suficientes. (puede agregar Unicode)
• No debería llenar toda la pantalla al inicio (¡Debería verse como una lluvia, duh!).
• Los colores obtienen puntos de bonificación (+5).
• Efectos : caracteres aleatorios, diferentes tamaños de otoño, se regenera periódicamente.
  

Puntos: (actualización)

• +32 puntos para comenzar.
• -1 punto por cada byte (no caracteres) en el código después del ** 1024 *** th * byte.
• Los puntos pueden llegar a cero y negativo.
• Nota: Los idiomas que usan caracteres multibyte deben contar bytes, no caracteres.
• +5 por cada nuevo efecto. (no publicado por otros)
• +15 por cualquiera de estos efectos:
  1. Viento (sopla personajes a un lado)
  2. Coincidencia de números (entrada del usuario, por ejemplo: 90210): el
     número se ubica aleatoriamente dentro de la matriz
     
  3. Sonar
  4. 
     Mensaje cifrado (entrada del usuario): los caracteres representan un mensaje secreto cifrado
  5. Modo Galaga:
     dispara ^ para destruir personajes
     

Marcador:

┌-----┬------------┬------------┬-------------┬---------------┬--------------┐
| pos |    name    |    type    |    bytes    |    effects    |    points  ^ |
|-----|------------|------------|-------------|---------------|--------------|
|1    |nitro2k01   |QBasic      |913          |Colours        |+57           |
|     |            |            |             |Colour Fade    |              |
|     |            |            |             |Sound (+15)    |              |
|-----|------------|------------|-------------|---------------|--------------|
|2    |squeamish   |HTML, Java- |1024         |Colours        |+47           |
|     |ossifrage   |Script, CSS |             |Transition     |              |
|     |            |            |             |Size Variation |              |
|-----|------------|------------|-------------|---------------|--------------|
|3    |manatwork   |Ruby        |374          |Colours        |+47           |
|     |            |            |             |Actual Words   |              |
|     |            |            |             |Character -    |              |
|     |            |            |             |      Disperse |              |
|-----|------------|------------|-------------|---------------|--------------|
|4    |plg         |Bash        |1024         |Colours        |+42           |
|     |            |            |             |Random Pause   |              |
|-----|------------|------------|-------------|---------------|--------------|
|5    |Timtech     |TI-84 calc  |120          |Umbrella       |+42           |
|     |            |            |             |Run Inside     |              |
|-----|------------|------------|-------------|---------------|--------------|
|6    |Samuel Cook |JavaScript  |830          |Colours        |+42           |
|     |            |            |             |Transition     |              |
└-----┴------------┴------------┴-------------┴---------------┴--------------┘

Nota: El marcador podrá / podría ser actualizado por cualquier persona después de publicar una respuesta válida. No exceda las diez primeras posiciones. ¡Agrega más efectos a tu código y supera tu propio puntaje!
Borrar la pantalla inicial, la limpieza, los errores, las bibliotecas de terceros, etc. no contarían para los puntos Recuerde incluir detalles sobre el no. de bytes utilizados y el nombre del idioma o programa.

Neo: ¿Qué intentas decirme? ¿Que puedo esquivar las balas?

Morfeo: No, Neo. Estoy tratando de decirte que cuando estés listo, no tendrás que hacerlo.

HTML, Javascript y CSS: 1024 bytes, 47 puntos

caracteristicas:

• Utiliza caracteres Unicode (no creo que esto sume ningún punto)
• Los senderos se desvanecen de verde brillante a verde oscuro mientras se dibujan (*)
• Los senderos también se desvanecen de verde oscuro a negro después de que el dibujo ha terminado (*)
• Tamaño de texto aleatorio en cada ruta (*)
• Los senderos se recolocan y cambian de tamaño aleatoriamente cada vez que se dibujan

(*) Reclamaré +5 puntos por cada uno de estos, pero avíseme si no está de acuerdo :-)

Manifestación:

http://ruletheweb.co.uk/matrix.html

Código fuente:

Exactamente 1024 bytes. Es un poco feo, me temo.

<head><style>*{margin:0;padding:0;line-height:1;overflow:hidden;}div{width:1em;position:absolute;}</style><script>
w=window;n=w.innerWidth;m=w.innerHeight;d=document;q="px";function z(a,b){return Math.floor(Math.random()*(b-a)+a)}f=" 0123456789";for(i=0;i<45;i++)f+=String.fromCharCode(i+65393);function g(){for(i=0;i<90;i++){r=d.createElement("div");for(j=z(20,50);j;j--){x=d.createElement("pre");y=d.createTextNode(f[z(0,56)]);x.appendChild(y);x.style.opacity=0;r.appendChild(x)}r.id="r"+i;r.t=z(-99,0);with(r.style){left=z(0,n)+q;top=z(-m,0)+q;fontSize=z(10,25)+q}d.body.appendChild(r);setInterval("u("+i+")",z(60,120))}}function u(j){e=d.getElementById("r"+j);c=e.childNodes;t=e.t+1;if((v=t-c.length-50)>0){if((e.style.opacity=1-v/32)==0){for(f in c)if(c[f].style)c[f].style.opacity=0;with(e.style){left=z(0,n)+q;top=z(-m/2,m/2)+q;opacity=1}t=-50}}e.t=t;if(t<0||t>c.length+12)return;for(f=t;f&&f>t-12;f--){s=1-(t-f)/16;if(f<c.length&&c[f].style){c[f].style.opacity=s;}}}
</script><body text=#0f0 bgcolor=#000 onload=g()>

Golpetazo

1024 bytes (incluidos los comentarios)

COL=80
ROW=$(tput lines)

cleanup() {
  wait # wait for background jobs (the drops)
  # clear; move cursor to (1,1); show cursor
  # reset color
  printf '\033[2J\033[1;1H\033[?25h\033[0;0m'
}

drop() { # $1=column ; $2=row to end on ; $3 = drop size (ranges from 5 to 15)
  for ((r=1; r<$2+$3+1; r++)); do
    # if before drop's end point : print lowest char in white
    [ $r -lt $2 ] && printf "\033[$r;$1H\033[0;0m\u$[RANDOM % 59 + 21]"

    # if before or on drop's end point : replace older white char with a green one
    [ $r -le $2 ] && printf "\033[$[r-1];$1H\033[0;32m\u$[RANDOM % 59 + 21]"

    # if drop's longer than it's size : erase last char
    [ $r -gt $3 ] && printf "\033[$[r-$3];$1H "

    # wait before moving drop down
    sleep .1
  done
}

# cleanup on exit
trap cleanup EXIT
# clear screen; hide cursor
printf '\033[2J\033[?25l'

# loop with delay
while sleep .1; do
  # start a drop in background : column; ending row; size
  drop $[RANDOM % COL] $[RANDOM % ROW + ROW/3] $[RANDOM % 10 + 5] &
done

Nuevos efectos:

• todo (primera entrada);)
• las gotas se detendrán al azar en la pantalla
• efectos de color fríos: el último color es blanco mientras que los otros son verdes
• los caracteres aleatorios y las secuencias de escape permanecen en la consola ... Ok, eso es un error, pero es porque el término no puede seguir el movimiento del cursor

Golfed @ 188 186 176 :

d(){ for((r=1;r<$2+41;r++));do $4"$3$r;$1H\u$[RANDOM%59+21]";(($r>$2))&&$4"$3$[r-$2];$1H ";$s;done;}
s=sleep\ .1;while $s;do d $[RANDOM%80] $[RANDOM%10+5] '\033[' printf\ &done

Esto funciona en una cuadrícula de 80x40. Puede cambiar eso en RANDOM%80la última línea y r<$2+41en la segunda. No borro las gotas después de que salen de la cuadrícula, así que cambie el tamaño de su término a 80x40 o cambie 41 a $LINES+1. Hay un par de cosas que no tiene en comparación con la versión completa:

• preparación o limpieza a término
• coloración elegante (toma 52 bytes, así que no vale la pena)
• detenerse al azar (aquí las gotas siempre van al fondo)
• Podría reducirlo a 174 al no especificar una longitud mínima para "gotas": $[RANDOM%10+5]se convertiría en$[RANDOM%15]

¡Incluso con esas limitaciones, creo que es genial!

Editar: intenté usar caracteres unicode como ossifrage apremiante, pero debido a que son caracteres de doble ancho, llenan la cuadrícula bastante rápido y termina pareciendo extraño.

También reduje la versión de golf usando puntos de código Unicode en lugar de ASCII, por lo que no tengo que volverme octal antes de obtener un personaje, guardando un paso. Hice lo mismo en la versión principal, pero agregué comentarios para mantenerlo en 1024 bytes.

Y luego cambié la comparación int de [ $r -gt $2 ]a (($r>$2)), ese espacio en blanco me estaba matando, pero no pude encontrar otro método que comparara ints y no cadenas. ¡Esto redujo la versión de golf a 176 btyes!

JavaScript, 830 bytes

Tiene todas las características clásicas como:

1. fondo negro
2. texto verde
3. texto blanco al caer
4. personajes al azar
5. agujeros vacíos
6. bucle infinito

window.onload=function(){
    var tbl=document.createElement('table'),
	body=document.body;
	body.style.backgroundColor='#000';
	body.style.color='#060';
	body.style.fontFamily='Lucida Console';

    for(var i = 0; i <= 30; i++){
        var tr = tbl.insertRow();
        for(var j = 0; j <= 50; j++){
            var td = tr.insertCell();
			td.style.width="2%";
        }
    }
    body.appendChild(tbl);
	setInterval(function(){
		rain(Math.floor((Math.random()*50)),0)
	},20);
}
function rain(n,i) {          
   setTimeout(function (){
	  var e=document.getElementsByTagName('tr')[i].childNodes[n];
	  e.style.color='#fff';
      e.innerHTML = '&#'+Math.floor((Math.random()*127)+1)+';';
	  setTimeout(function(){e.style.color=''},200)
	  
      if (i++ < 30) rain(n,i);
   },20);
};

Me gusta porque es increíblemente liviano, fluido en movimiento y simple. ¡disfrutar!

QBasic 1, 587 bytes, 32 + 5 = 37 puntos

DECLARE SUB d (p!, s!, x!, y!)
DIM t(80)
FOR i = 1 TO 80
    t(i) = INT(-50 * RND)
NEXT
s = TIMER

CLS
WHILE 1
    FOR i = 1 TO 80
        IF t(i) > 28 THEN t(i) = 0
        t(i) = t(i) + 1
        y = t(i)
        d 0, 0, i, y - 6
        d 2, 0, i, y - 5
        d 2, 0, i, y - 4
        d 10, 0, i, y - 3
        d 10, 0, i, y - 2
        d 11, 0, i, y - 1
        d 0, 2, i, y
    NEXT

    l = TIMER
    WHILE l = TIMER
    WEND
WEND

SUB d (p, s, x, y)
COLOR p, s
IF y > 0 AND y < 24 THEN LOCATE y, x: PRINT CHR$(33 + (x * y) MOD 200);
END SUB

Captura de pantalla de muestra:

32 puntos base + 5 puntos para el color. Pero como estoy flotando felizmente por debajo de 1024 bytes, incluso sin recortar u optimizar espacios en blanco, agreguemos algunas cosas más para robar algunos puntos:

QBasic 2, 913 bytes, 32 + 5 + 15 + 5 = 57 puntos

DECLARE SUB d (p!, s!, x!, y!)
DIM t(80)
FOR i = 1 TO 80
    t(i) = INT(-50 * RND)
NEXT
s = TIMER
f = 0
w$ = "bullet"
o = 1
CLS
WHILE 1
    FOR i = 1 TO 80
        IF t(i) > 28 THEN t(i) = 0: IF f THEN SOUND 100 * i, 1
        t(i) = t(i) + 1
        y = t(i)
        d 0, 0, i, y - 6
        d 2 + x, 0, i, y - 5
        d 2 + x, 0, i, y - 4
        d 10 + x, 0, i, y - 3
        d 10 + x, 0, i, y - 2
        d 11 + x, 0, i, y - 1
        d 0, 2 + x, i, y
    NEXT
    k$ = INKEY$
    IF k$ <> "" THEN
        IF MID$(w$, o, 1) = k$ THEN
            o = o + 1
            IF o = LEN(w$) + 1 THEN z = 1: f = 100
        ELSE
            o = 1
        END IF

    END IF
    x = x + z
    l = TIMER
    WHILE l = TIMER
    WEND

WEND

SUB d (p, s, x, y)
COLOR p MOD 16, s MOD 16
IF y > 0 AND y < 24 THEN LOCATE y, x: PRINT CHR$(33 + (x * y) MOD 200);
END SUB

Captura de pantalla de muestra (efecto de color activado):

Las mismas características que la primera. Además tiene:

• Color (+5)
• Una contraseña para activar funciones adicionales. (Estoy reclamando +5 para esto como una nueva característica).
• La contraseña activa un desvanecimiento de paleta y efectos de sonido. (+15 para sonido)

Video que lo muestra en acción, incluido el efecto de color y el efecto de sonido activado por la contraseña:

http://www.youtube.com/watch?v=MQc-FDl_AZ8

GTB , 42 puntos

Ejecutado desde una calculadora TI-84, aproximadamente 100 bytes:

"  O O    O O   O"→Str1:"O  O   O O  O O "→Str2:0→X[@getkey=25$~""~""~""~""~""~""~""p;&@round(r;$~""#@round(r;$~Str1#~Str2&:&]

Efectos

Como la calculadora es negra + blanca para empezar, no puede hacer mucho allí ...

• Paraguas : al presionar la tecla arriba, se despeja la lluvia y se mantiene seco hasta que se presionaEnter
• Ejecutar adentro : al presionar se ONrompe el programa y se obtiene un techo agradable para mantenerte seco (puedes volver a salir bajo la lluvia presionando Enterdos veces

Rubí: 374 caracteres.

$><<"^[[2J"
w=->c,d,m{$><<"^[[0;3%d;%dm^[[%d;%dH%s"%[c,d[4],d[3]+d[1]-m,d[2],d[0][d[1]-m]]}
t=%w{Stack Exchange Programming Puzzle Code Golf}
r=[]
loop{r.map{|o|w[2,o,1]if o[1]>0
w[7,o,0]
o[1]+=1
o[0][0]==" "?r.delete(o):(o[0]=" "*o[1])*o[1]=0if o[1]>o[0].size}
sleep 0.1
r<<[(k=rand(10)%2)==0 ?t.sample: [*?a..?z].sample(rand(10)+5)*"",0,rand(80),rand(20),k+1]while r.size<25}

(Nota: ^[son caracteres individuales).

Descripción:

• 25 ejecuciones simultáneas (mantenidas bajas para que los textos predefinidos sigan siendo legibles)
• cada carrera tiene un 50% / 50% de posibilidades de ser
  • una palabra predefinida - mostrada en colores brillantes
  • una cadena aleatoria de 5..15 letras minúsculas, que se muestran en colores oscuros
• mientras se muestra la ejecución, el color de fondo es blanco, los otros verdes
• una vez que la ejecución se muestra por completo, se elimina carácter por carácter

Ejecución de muestra: