text:
ASCII Art Calendar
Let's make an ASCII art clock and calendar that tells us the current month, day of the month, day of the week, hour, minute, and whether it's night or day (but not the year or second).
At any particular time the calendar will look something like this: (it looks better with less line spacing)
 ________________________________________________________________
|\ ____________________________________________________________ /|
| |                  ___                                       | |
| |                _(   )                                      | |
| |               (___)__)           -.-                       | |
| |                                                            | |
| |                                                            | |
| |      -.-                                                   | |
| |         -.-                                                | |
| |                     ___                                    | |
| |                   _(   )                                   | |
| |                  (___)__)                                  | |
| |                                                            | |
| |                                          ___               | |
| |                                        _(   )              | |
| |    _                                  (___)__)             | |
| |   /|\                                                      | |
| |  / | \                                                     | |
| | /__|__\                                                    | |
| |____|____                                                   | |
| |\_______/~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-~~-~~~~~| |
| |____________________________________________________________| |
|/______________________________________________________________\|

It is always a 66 by 23 character "picture frame" whose border never changes.
The image within the frame tells us the time and date:

During the day (6:00am - 5:59pm) the month is determined by the number of birds (-.-) in the sky. January = 1 bird, February = 2 birds, etc.
During the night (6:00pm - 5:59am) the birds are replaced with 3 times as many stars (*). January = 3 stars, February = 6 stars, etc. Birds and stars are never in the sky at the same time.
The day of the month is determined by the number of characters between the two dashes (-) on the water. e.g. ~~-~~~~-~~ means it is the fourth day of the month. Depending on the minute, the boat may need to be between the dashes (the dashes do not loop around).
The day of the week is determined by the number of clouds in the sky (all clouds look the same). Sunday = 0 clouds, Monday = 1 cloud, ..., Saturday = 6 clouds.
The hour is determined by the level of water (and the boat). At its lowest (as above) it is 1 o'clock, during 2 o'clock it is one character higher, and so on up to 12 o'clock, then back to 1 o-clock. (It's a 12 not a 24 hour clock.)
The minute is determined by the horizontal position of the boat. At the top of the hour the boat touches the left edge of the frame (as above). At each subsequent minute the boat moves right by one character. In minutes 51 to 59 it loops from the right side of the frame back to the left.

So, given that the example above has 3 birds, 3 clouds, 2 chars between dashes, the water at the lowest level, and the boat on the far left we can tell that the date is Wednesday March 2nd, and the time is 1:00pm.
Here is another example from Sunday April 25th, at 3:58am:
 ________________________________________________________________
|\ ____________________________________________________________ /|
| |                                                            | |
| |                                                     * *    | |
| |                            *       *                 *     | |
| |               *                                            | |
| |                                                            | |
| |                           *                                | |
| |         *                      *                           | |
| |                                                            | |
| |                                 *                          | |
| |                                                            | |
| |                                 *                          | |
| |  _                                                         | |
| | /|\                          *                             | |
| |/ | \                                                       | |
| |__|__\                                                     /| |
| |__|____                                                   __| |
| |______/~~~~~~~~~~~~~~~~~~~-~~~~~~~~~~~~~~~~~~~~~~~~~-~~~~~\_| |
| |                                                            | |
| |                                                            | |
| |____________________________________________________________| |
|/______________________________________________________________\|

Goal
Your goal is to write the shortest program possible that outputs these ASCII art "calendars" to stdout using the time when the program is run.
Every run of the program should output one time-scene. Updates should not be automatic (or animated).
The clouds, stars, and birds, should be placed randomly in the sky (so every run, even ones at the same time are likely to be different). They should never overlap the boat or each other. (Also the water dashes should not overlap the boat hull.)
Notice that nothing I have described appears underwater. This is for you to do. During one predetermined hour of every week (your choice), something interesting should be drawn underwater. It could be a sea monster or sunken ship or anything, it's up to you. During that hour you may even alter the design of the rest of the scene (staying in the frame bounds).
Scoring
This is a code-golf popularity-contest combo.
Your score is (bytes in program) - 4 * (upvotes - downvotes). The lowest score wins.
Use http://mothereff.in/byte-counter as a byte counter if you use non-ASCII characters.
Notes and Updates

You may use buoys instead of dashes, since, lets face it, they're much more appropriate:
   |     |
~~(_)~~~(_)~~ (3rd of the month)

The dashes (or buoys) do not have to be random but it would be nice if they were.
Your "special hour" should last 60 minutes from the top of the hour to 1 minute before the next hour.
During the special hour the things you draw underwater may move and may alter the surface and the sky when it makes sense (e.g. sea monster eating the boat, black hole forming at the sea floor, etc.)

Would it be wrong of us to start downvoting all your questions/answers until you are back under 4k so you can continue posting awesome questions?

How wonderfully fanciful. There's no point in me trying to golf it, but heck, I'm gonna try and write it (I'll still try and golf too).

@KyleKanos But then who would want to look at all my negatively score questions ;)

This seems like something used by Cold War spies to secretly communicate meeting times.

Does the clock update as time passes, or do we have to re-run the program for an update?

@Ourous You have to re-run the program for updates. (And the randomly placed clouds/birds/etc. don't need to stay in the same place for multiple runs in the same minute.)

Why not two buoys instead of dashes ? They'd be more visible and less out-of-place :) "  |>\n~(_)~\n  °"

@Quentin I actually considered doing almost exactly that but the buoys didn't look right to me.

You can always leave the buoys design to the participants :)

@Quentin Tell you what. You're welcome to use simple buoys in place of dashes if you prefer. :)

@MartinBüttner It should be birds from 6:00am to 5:59pm, then stars from 6:00pm to 5:59am.

@Calvin'sHobbies how random should the clouds, stars and birds be placed? Has it do be totally random across all free space, or is it enough if the output is different each run (so it would be random inside some constraints)?

@Calvin'sHobbies If say, a person, is already coding while others are still asking for more and more specification, is the coder bound by those later specifications?

@tim Having it random within reasonable constraints is fine. e.g. the stars look better near the top of the frame so it's ok to only draw them in the top few rows. What I DON'T want to see is CLOUDCLOUDCLOUDCLOUDBIRDBIRDBIRDBIRD all bunched in a line with no effort to position them realistically. Remember that this is partially a popularity content so the submissions with boring random positioning are not likely to be voted up.

@AndoDaan No, I won't be a stickler about that, but I think that my only strict adjustment so far was the 5:59 thing.

Yes please do dump any excess ideas in the sandbox

Every so often, drop back in unexpectedly like a creature of myth

@MartinBüttner Whoops, didn't see your other questions. The dashes do not have to be randomized but it would be nice if they didn't appear in the same spot all the time. During the special hour your underwater thing is allowed to change every minute and could even go above the surface when it makes sense (e.g. animating a sea monster swallowing the ship).

Should've asked before doing it, but is it okay to change the water color during the hour?

Won't it be too crowded to fit everything in the sky at 12am on a Saturday in December?

@Ourous Thats fine

@Timmy There's plenty of room.

Ruby, At World's End, 1260 1070 967 bytes
Anyone remember that Pirates of the Caribbean film?
c=("   #{?_*60}
")*2
c+="| |#{' '*60}| |
"*19+c
[67,132,-2,-66,-67,-69,-71,-132,-134].map{|i|c[i]=?|}
a=c[68]=c[-3]=?\\
e=c[131]=c[-66]=?/
[1,2,-4,-65,63,64].map{|i|c[i]=?_}
t=Time.now
w,_,n,l,d,m=t.wday,*t.to_a
p=l>11
q=(l-1)%12+1
h=(20-(l-1)%12)*67+3
c[h,60]=?~*60
f=(n+9)%60
f=f+d>58?n>d+2?0:n-12:f
c[h+f]=c[h+f+d+1]=?-
s=l==18&&w==0
z=->s{s.chars.map(&:to_i)}
b={?_=>z['5410110125'+g='020304050607121315161718222326'],e=>z['08213243'],a=>z['00273645'],?|=>z['14243444'],?#=>[3,3,3,5]}
b={?_=>z[g+'272855140824'].map{|i|i-1},a=>b[e],e=>b[a],?|=>z['142434']}if s
b.each{|k,v|v.each_slice(2){|j,i|c[h-67*j*(s ?-1:1)+(i+n)%60]=k}}
r=->(m,t){k=0
(x=rand(53)
y=rand(19-q)
m.values.flatten.each_slice(2).any?{|j,i|c[h-(y+j)*67+i+x]!=' '}? next: m.each{|k,v|v.each_slice(2){|j,i|c[h-(y+j)*67+i+x]=k}}
k+=1)while k<t}
r[{?(=>[1,0,2,2],?)=>z['141726'],?_=>z['111213151621333435'],?#=>z['232425']},w]
r[l>5&&l<18?{?-=>[1,0,1,2],?.=>[1,1]}:{?*=>[1,0]},m]
puts c.tr(?#,' ')

There's still a lot of room for improving the golfitude there, but it's a start.
Now what's with the movie reference? Apparently that Green Flash happens a lot more often than Jack Sparrow wants us to believe. In fact, it happens about once a week instead of once every ten years. Every Sunday at sunset, the Black Ruby (hrhr) does one round in the land of the dead:
 ________________________________________________________________
|\ ____________________________________________________________ /|
| |                                                            | |
| |                                                            | |
| |                                                            | |
| |                                                            | |
| |                                                            | |
| |                                                            | |
| |                                                            | |
| |                                                            | |
| |                                                            | |
| |                                                            | |
| | *                          *                       *       | |
| |                     *                            *         | |
| |         *  *                  *             _______        | |
| |-~~~~~~~~~~~~-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~/_______\~~~~~~~| |
| |                                             ___|___        | |
| |                                             \  |  /        | |
| |                                              \ | /         | |
| |                                               \_/          | |
| |                                                            | |
| |____________________________________________________________| |
|/______________________________________________________________\|

Java - Cute Kraken (A lot of bytes)
EDIT: Further improvements to birds/stars bring up top and clouds, now the most busy calendar (12pm, Saturday, December) works about 70% of the time. Other 30% I get a (get ready for this) Stack Overflow error because I use recursion. New pics of busiest possible calendar and new Kraken pic, which shows off the lows/highs of stars/clouds.
Now better handles situations in which the random scattering of stars/birds prevents the random insertion of clouds. When things are too crowded and it doesn't work after 200 tries, we re-do the stars/birds in hopes that the next configuration will allow the clouds some personal space.
Who's a cute wittle kwaken? Who's a cute wittle kwaken? You are! You are!
Minor edits, still no golfing. Kwaken shows up on the 9s because he knows everyone expects him at midnight. He's small and shy now, but one day he hopes to eat the ship.
Clouds have a tendency to be low in the sky, while stars and birds like to fly above them; things tend to get a little crowded around 8 o'clock though.
import java.text.SimpleDateFormat;
import java.util.Calendar;

public class TimeFlies
{
   static char[][] frame = new char[23][66];
   static char[] bird = new char[] {'-', '.', '-'};
   static char[][] boat = new char[][]{
   {' ', ' ', ' ', ' ', '_', ' ', ' ', ' ', ' '},
   {' ', ' ', ' ', '/', '|', '\\', ' ', ' ', ' '},
   {' ', ' ', '/', ' ', '|', ' ', '\\', ' ', ' '},
   {' ', '/', '_', '_', '|', '_', '_', '\\', ' '},
   {'_', '_', '_', '_', '|', '_', '_', '_', '_'},
   {'\\', '_', '_', '_', '_', '_', '_', '_', '/'},
   };
   static char[][] cloud = new char[][]{
   {' ', ' ', ' ', '_', '_', '_', ' ', ' '},
   {' ', '_', '(', ' ', ' ', ' ', ')', ' '},
   {'(', '_', '_', '_', ')', '_', '_', ')'},
   };
   static char[][] kraken = new char[][]{
   {' ', ' ', ' ', '_', '_', '_', '_', '_', '_', '_', '_', ' ', ' ', ' ', ' '},
   {' ', ' ', '/', ' ', ' ', '_', ' ', ' ', ' ', '_', ' ', '\\', ' ', ' ', ' '},
   {' ', '|', ' ', ' ', '|', '_', '|', ' ', '|', '_', '|', ' ', '|', ' ', ' '},
   {' ', ' ', '\\', '_', '_', '_', '\\', ' ', '/', '_', '_', '/', ' ', ' ', ' '},
   {' ', ' ', ' ', '/', '|', ' ', '|', ' ', '|', ' ', '|', '\\', ' ', ' ', ' '},
   {'_', '_', '/', ' ', '|', ' ', '|', ' ', '|', ' ', '|', ' ', '\\', '_', '_'},
   {' ', ' ', '_', '/', ' ', ' ', '|', ' ', '|', ' ', ' ', '\\', '_', ' ', ' '},
   {' ', ' ', ' ', ' ', ' ', '/', ' ', ' ', ' ', '\\', ' ', ' ', ' ', ' ', ' '}};

   static int day, month, hours, minutes, weekday, attempts = 0;
   static boolean isFirstTime, birds = true;
   static String timeStamp;

   public static void main()
   {
       timeStamp = new SimpleDateFormat("MMddHHmm").format(Calendar.getInstance().getTime());
       isFirstTime = true;
       retry();
   }

   public static void retry()
   {

       day = Integer.parseInt(timeStamp.substring(2, 4));
       month = Integer.parseInt(timeStamp.substring(0, 2));
       hours = Integer.parseInt(timeStamp.substring(4, 6));
       minutes = Integer.parseInt(timeStamp.substring(6, 8));

       Calendar c = Calendar.getInstance();
       c.set(2014, month, day);
       weekday = c.get(Calendar.DAY_OF_WEEK) - 1;

       int timeTemp = hours*60 + minutes;
       if(timeTemp < 360 || timeTemp > 1080)
       {
           birds = false;
           month *= 3;
       }
       if(hours > 12)
           hours -= 12;
       initiateFrame();

       if(isFirstTime)
       {
           printFrame();
           isFirstTime = false;
       }
   }

   public static void insertStuff()
   {
       for(int i = 0; i < boat.length; i++)
           for(int k = 0; k < boat[0].length; k++)
           {
               if(3+k+minutes > 62)
                   frame[15 + i - hours][3 + k + minutes-60] = boat[i][k];
               else
                   frame[15 + i - hours][3 + k + minutes] = boat[i][k];
           }

       boolean beganDayCount = false;
       for(int i = 0; i <= 22; i++)
           for(int k = 0; k <=65; k++)
               if(i == (20 - hours) && (k > 2 && k < 63) && frame[i][k] == ' ')
               {
                   if(!beganDayCount)
                   {
                       frame[i][k] = '-';
                       beganDayCount = true;
                   }
                   else
                   {
                       if(day > 0)
                           frame[i][k] = '~';
                       if(day == 0)
                           frame[i][k] = '-';
                       else
                           frame[i][k] = '~';
                       day--;
                   }
               }
       putInBirdsOrStars();
       putInClouds();
       if(hours == 9)
           putInKraken();
   }

   public static void putInKraken()
   {
       for(int i = 0; i < kraken.length; i++)
           for(int k = 0; k < kraken[0].length; k++)
               frame[i + 12][k + 20] = kraken[i][k];
   }

   public static void putInClouds()
   {
       int x = (int)(Math.random() * 7) + (14-hours);
       int y = (int)(Math.random() * 54) + 2;
       boolean noFreeSpace = true;

       for(int i = 0; i < cloud.length; i++)
       {
           for(int k = 0; k < cloud[0].length; k++)
           {
               if(frame[x + i][y + k] == ' ' )
                   noFreeSpace = false;
               else
               {
                   noFreeSpace = true;
                   break;
               }
           }
           if(noFreeSpace)
               break;
       }

       if(x + 2 > 20 - hours)
           noFreeSpace = true;

       if(!noFreeSpace)
       {
           for(int i = 0; i < cloud.length; i++)
               for(int k = 0; k < cloud[0].length; k++)
                   frame[x + i][y + k] = cloud[i][k];
           weekday--;
       }

       attempts++;
       if(attempts > 200)
       {
           attempts = 0;
           retry();
       }
       if(weekday > 0)
           putInClouds();
   }

   public static void putInBirdsOrStars()
   {
       int x = (int)(Math.random() * 5) + (12 - hours);
       int y = (int)(Math.random() * 60) + 2;
       boolean freeSpace = false;

       for(int i = 0; i < bird.length; i++)
           if(frame[x][y] == ' ' && frame[x][y + 1] == ' ' && frame[x][y + 2] == ' ')
               freeSpace = true;

       if(x > 20- hours)
           freeSpace = false;
       if(birds && freeSpace)
       {
           for(int i = 0; i < bird.length; i++)
               frame[x][y++] = bird[i];
           month--;
       }
       else if(freeSpace)
       {
          frame[x][y] = '*';
          month--;
       }
       if(month > 0)
           putInBirdsOrStars();
   }

   public static void initiateFrame()
   {
       for(int i = 0; i <= 22; i++)
           for(int k = 0; k <=65; k++)
           {
               if(((k == 0 || k == 65) && (i > 0)) || ((k == 2 || k == 63) && (i > 1 && i < 22)))
                   frame[i][k] = '|';
               else if((i == 0 && (k > 0 && k < 65)) || ((i == 1 || i == 21) && (k > 2 && k < 63)) || (i == 22 && (k > 1 && k < 64)))
                   frame[i][k] = '_';
               else
                   frame[i][k] = ' ';
           }

       frame[1][1] = '\\'; frame[1][64] = '/'; frame[22][1] = '/';frame[22][64] = '\\';
       insertStuff();
   }

   public static void printFrame()
   {
       for(int i = 0; i <= 22; i++)
       {
           for(int k = 0; k <=65; k++)
               System.out.print(frame[i][k]);
           System.out.println();
       }
   }
}

Casual output
 ________________________________________________________________
|\ ____________________________________________________________ /|
| |                                                      -.-   | |
| |                                   -.-                      | |
| |                                                            | |
| |      -.-                                                   | |
| |                                                            | |
| |               -.-                                          | |
| |                                                            | |
| |                     -.-                           -.-      | |
| |    -.-                                  ___                | |
| |            -.-                        _(   )      ___      | |
| |             ___                      (___)__)   _(   )     | |
| |           _(   )        ___               _    (___)__)    | |
| |          (___)__)     _(   )             /|\               | |
| |     ___              (___)__)   ___     / | \              | |
| |   _(   )                      _(   )   /__|__\             | |
| |  (___)__)                    (___)__) ____|____            | |
| |-~~~~~~~~~~~~~-~~~~~~~~~~~~~~~~~~~~~~~~\_______/~~~~~~~~~~~~| |
| |                                                            | |
| |                                                            | |
| |____________________________________________________________| |
|/______________________________________________________________\|

super busy output
 ________________________________________________________________
|\ ____________________________________________________________ /|
| |  *  * **    * *        *  *    **       * *   *    * *  *  | |
| |*  _   *  *       **  *        *         *   *  *      *    | |
| |  /|\*    ___  *  **  *     *        *      ___  *     *    | |
| | / | \  _(   )    ___      ___       ___  _(   )    ___     | |
| |/__|__\(___)__) _(   )   _(   )    _(   )(___)__) _(   )    | |
| |___|____       (___)__) (___)__)  (___)__)       (___)__)  _| |
| |_______/-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-~~~~~~~~~~~~~~~~~~~\| |
| |                                                            | |
| |                                                            | |
| |                                                            | |
| |                                                            | |
| |                                                            | |
| |                                                            | |
| |                                                            | |
| |                                                            | |
| |                                                            | |
| |                                                            | |
| |                                                            | |
| |                                                            | |
| |____________________________________________________________| |
|/______________________________________________________________\|

If we're to introduce our kraken by hard coding some values, we get...
 ________________________________________________________________
|\ ____________________________________________________________ /|
| |                                                            | |
| |*           *  *     *                                   *  | |
| |  *       *                                    *   *   *    | |
| |*          ___      *  *                   *    *           | |
| |         _(   )  _         ___      *   *                   | |
| |     *  (___)__)/|\*     _(   )  *   *    *   ___   *   *   | |
| |   ___         / | \    (___)__)   ___      _(   )    ___   | |
| | _(   )       /__|__\            _(   )    (___)__) _(   )  | |
| |(___)__)     ____|____          (___)__)           (___)__) | |
| |-~~~~~~~~~~~~\_______/~~~-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~| |
| |                    ________                                | |
| |                   /  _   _ \                               | |
| |                  |  |_| |_| |                              | |
| |                   \___\ /__/                               | |
| |                    /| | | |\                               | |
| |                 __/ | | | | \__                            | |
| |                   _/  | |  \_                              | |
| |                      /   \                                 | |
| |                                                            | |
| |____________________________________________________________| |
|/______________________________________________________________\|

Love that Squidward-like Kraken)

Python3 - Pirates and Jellyfish: 1580 1472 bytes
Every Wednesday at midnight a pirate ship sinks our boat. The noise wakes up a giant jellyfish who randomly roams the frame for an hour.
from random import*
from datetime import*
l=len;r=range
n=randint
def f(s,p,*a):
 global c,o;j=l(s[0])
 while 1:
  x=n(3,63-j);y=n(3,p);g=y+l(s);h=x+j
  if not(o[y][x]or o[g][h]or o[g][x]or o[y][h]):break
 if l(a)!= 0:x,y=a
 for w in r(l(s)):
  for m in r(j):c[y+w][x+m]=s[w][m];o[y+w][x+m]=1
E=datetime.now();D=(E.weekday()+1)%7
h=E.hour;M=E.month
t=6<h<18;N=(3*M,M)[t]
H=9if h==0 else 21-h%12
s=min(H-1,12)
o=[[0]*66 for i in r(23)]
c=[['']*66 for i in r(23)]
c[0]=[' ']+['_']*64+[' ']
c[1]=['|','\\']+['_']*62+['/','|']
for i in r(2,21):c[i]=['|',' ','|']+[' ']*60+['|',' ','|']
c[21]=['|',' ','|']+['_']*60+['|',' ','|']
c[22]=['|','/']+['_']*62+['\\','|']
for i in r(3,63):c[H][i]='~'
Z=(D!=3or h!=0)
B=(['    _~_      ','  __)__)__   ','  )_))_))_)  ','.--:--:--:-=/',' \\_o__o__o_/ '],['    _    ','   /|\\   ','  / | \  ',' /__|__\\ ','____|____','\\_______/'])[Z]
j=l(B[0]);y=H-l(B)+1;x=E.minute
while 1:
 b=n(3,63)
 if b<x or b>(x+j):break
z=E.day+1;d=b+z
if b<x<d:d+=j
if d>63:d=b-z
if d<x<b:d-=j
c[H][b]=c[H][d]='-'
for w in r(l(B)):
 for m in r(j):
  g=x+m;k=y+w
  if g>59:c[k][g-57]=B[w][m];o[k][g-57]=1
  else:c[k][g+3]=B[w][m];o[k][g+3]=1
f((["  ,'',  ",".°____°."," :::::: ",",';:::'."," ,';:'. "],[''])[Z],s,n(3,50),n(10,13))
f((['  o  ° o °','°________°','/___°____\\'],[''])[Z],s,15,18)
for i in r(D):f(['   ___  ','  (   ) ','(___)__)'],s-3)
for i in r(N):f(('*',['-.-'])[t],s)
for w in r(23):
 for m in r(66):print(c[w][m],end='')
 print('')

Example at Tuesday Aug 19 23:27

On Wednesdays around midnight:

Cobra - 994
Without Bouys: 994
class P
    def main
        r,d=Random(),DateTime.now
        h,y,t,a=(d.hour+23)%24+1,d.day,d.month,d.dayOfWeek to int
        u,i,q=18-(h-1)%12,List<of String>[](20),1-(h+7)%24//13
        for p in 20
            i[p],s=['| |\n'],'__'
            for x in 60,i[p],s=[if(p-u,'[' _'[p//19]]','~')]+i[p],s+'_'
        for g in 6,for c in 9,i[u-g][(d.minute+c)%60]='[r'\_______/____|____ /__|__\   /#|#\     /|\       _    '[g*9+c]]'
        while x,if'~'==i[u][p-=p-r.next(60-y)]==i[u][p+y+1],i[u][p],i[u][p+y+1],x='-','-',0
        while g+c
            o,c,g=i,a,t+t*q*2
            for z in 99,if if(c,o[y-=y-r.next(u-2)][x-=x-r.next(52):x+8]+o[y+1][x:x+8]+o[y+2][x:x+8],o[y-=y-r.next(u)][x-=x-r.next(60-3+3*q):x+4-3*q]).join('').trim==''and g,for m in 3-(p-=p-if(c,0,1))*2,for n in 8-p*5,o[y+m][x+n-p*n*q],c,g=if(c,'['   ___   _(###) (___)__)'[m*8+n]]',['['-.-'[n]]','*'][q]),c-(m+n)//9,g-p*n//2
        print' _[s]_ \n|\\[s]/|'
        for l in o,for k in['| |']+l
            Console.foregroundColor=if(k<>'~'or h+a>1,7,9)to ConsoleColor
            Console.write(if(k=='#',' ',k))
        print'|/[s]\\|'

With Bouys: 1084
class P
    def main
        r,d=Random(),DateTime.now
        h,y,t,a=(d.hour+23)%24+1,d.day,d.month,d.dayOfWeek to int
        u,i,q=18-(h-1)%12,List<of String>[](20),1-(h+7)%24//13
        for p in 20
            i[p],s=['| |\n'],'__'
            for x in 60,i[p],s=[if(p-u,'[' _'[p//19]]','~')]+i[p],s+'_'
        for g in 6,for c in 9,i[u-g][(d.minute+c)%60]='[r'\_______/____|____ /__|__\   /#|#\     /|\       _    '[g*9+c]]'
        while x<>3,if''==(i[u][p-=p-r.next(58-y):p+3]+i[u][p+y+3:p+y+7]).join('').trim(c'~')
            i[u-1][p+1]=i[u-1][p+y+4]='|'
            for x in 3,i[u][p+x]=i[u][p+y+3+x]='['(_)'[x]]'
        while g+c
            o,c,g=i,a,t+t*q*2
            for z in 99,if if(c,o[y-=y-r.next(u-2)][x-=x-r.next(52):x+8]+o[y+1][x:x+8]+o[y+2][x:x+8],o[y-=y-r.next(u)][x-=x-r.next(60-3+3*q):x+4-3*q]).join('').trim==''and g,for m in 3-(p-=p-if(c,0,1))*2,for n in 8-p*5,o[y+m][x+n-p*n*q],c,g=if(c,'['   ___   _(###) (___)__)'[m*8+n]]',['['-.-'[n]]','*'][q]),c-(m+n)//9,g-p*n//2
        print' _[s]_ \n|\\[s]/|'
        for l in o,for k in['| |']+l
            Console.foregroundColor=if(k<>'~'or h+a>1,7,9)to ConsoleColor
            Console.write(if(k=='#',' ',k))
        print'|/[s]\\|'

At 1am every Sunday, the endless expanse of the tilde sea on comes alive with a dazzling blue shine. Hope returns to the people of the desolate shell-world.

C# 1124 1128bytes
Once a week, a shoddy ASCII submarine should appear for an hour below the waterline, and increase my byte count noticeably hopefully this code will actually work now. I dread to think what happens on Saturdays at 11:00 in December...
using System;class P{static string G(DateTime t){Func<int,int>K=new Random().Next;int i,j,D=t.Day,H=t.Hour,W=19-H%12,E=(int)t.DayOfWeek;var M=new char[60,19];Func<int,int,int,string,bool>T=(x,y,w,s)=>{for(i=0;i<s.Length;)if(M[(x+i%w)%60,y+i++/w]>0)return 0>1;for(;i-->0;)M[(x+i%w)%60,y+i/w]=s[i];return 1>0;};T(t.Minute,W-5,9,@"    _       /|\     / | \   /__|__\ ____|____\_______/");while(M[j=K(59-D),W]+M[j+D+1,W]>0){}M[j+D+1,W]=M[j,W]='-';for(j=60;j-->0;)T(j,W,1,"~");for(;++j<E;)while(!T(K(53),K(W-3),8,"   ___   _(   ) (___)__)")){}var N=H<6|H>=18;for(j=0;j++<t.Month*(N?3:1);)while(!T(K(60-(N?1:3)),K(W-1),3,N?"*":"-.-")){}if(H==18&E==4)T(K(59),W+2,17,@"    __            __/  \_________ (_______________)");var res=" ________________________________________________________________\n|\\ ____________________________________________________________ /|\n| |";for(j=0;j<19;j++){for(i=0;i<60;i++)res+=M[i,j];res+="| |\n| |";}return res+"____________________________________________________________| |\n|/______________________________________________________________\\|";}static void Main(){Console.Write(G(DateTime.Now));}}

Somewhat formatted code (which re-draws every 15seconds because I mis-read the spec):
using System;

class P
{
    static string G(DateTime t)
    {
        Func<int,int>K=new Random().Next;
        int i,j,D=t.Day,H=t.Hour,W=19-H%12,E=(int)t.DayOfWeek;
        var M=new char[60,19];

        Func<int,int,int,string,bool>T=(x,y,w,s)=>
        {
            for(i=0;i<s.Length;)
                if(M[(x+i%w)%60,y+i++/w]>0)
                    return 0>1;
            for(;i-->0;)
                M[(x+i%w)%60,y+i/w]=s[i];
            return 1>0;
        };

        T(t.Minute,W-5,9,@"    _       /|\     / | \   /__|__\ ____|____\_______/");

        while(M[j=K(59-D),W]+M[j+D+1,W]>0){}
        M[j+D+1,W]=M[j,W]='-';

        for(j=60;j-->0;)
            T(j,W,1,"~");

        for(;++j<E;)
            while(!T(K(53),K(W-3),8,"   ___   _(   ) (___)__)")){}

        var N=H<6|H>=18;
        for(j=0;j++<t.Month*(N?3:1);)
            while(!T(K(60-(N?1:3)),K(W-1),3,N?"*":"-.-")){}

        if(H==18&E==4)
            T(K(59),W+2,17,@"    __            __/  \_________ (_______________)");

        var res=@" ________________________________________________________________
|\ ____________________________________________________________ /|
| |";

        for(j=0;j<19;j++)
        {
            for(i=0;i<60;i++)
                res+=M[i,j];
            res+="| |\n| |";
        }

        return res+@"____________________________________________________________| |
|/______________________________________________________________\|";
    }

    static void Main()
    {
        for(;;)
        {
            Console.Clear();
            Console.Write(G(DateTime.Now));
            System.Threading.Thread.Sleep(15000);
        }
    }
}

Example output (should read 3:31, Wednesday, 13th August):
 ________________________________________________________________
|\ ____________________________________________________________ /|
| |                                                            | |
| |         *  *                                               | |
| |                         *                                  | |
| |      *                 *                                   | |
| |                     *                                      | |
| |            ___                        * *                  | |
| |          _(   )                                            | |
| |        *(___)__)      *                   *                | |
| |                                  *                         | |
| |           ___    *                                      *  | |
| |     *   _(   )  *                             ___    *     | |
| |      * (___)__)                   _         _(   )         | |
| |        *             *           /|\       (___)__)  *  *  | |
| |                                 / | \     *           *    | |
| |                                /__|__\                     | |
| |                               ____|____                    | |
| |~~-~~~~~~~~~~~~~-~~~~~~~~~~~~~~\_______/~~~~~~~~~~~~~~~~~~~~| |
| |                                                            | |
| |                                                            | |
| |____________________________________________________________| |
|/______________________________________________________________\|

Lua - more than stars
I'm done!
Well, not done done. I'm done with this code and challenge. It's not golfed, it's missing the month indicator. There's no avoidance... I'm only posting it so that in the off chance nobody completes this chalange, at least you saw something, got an idea.
--Halfed Assed Calender
math.randomseed(os.time())
math.randomseed(os.time())
math.randomseed(os.time())
local bh=os.date("%I")
local bm=os.date("%m")
local wdm=os.date("%d")
local cdw=os.date("%w")
local bsm=os.date("%M")
local hh=tonumber(os.date("%H"))
local function tp(t)
    for i=1,#t do
        for k= 1, #t[i] do
            io.write(t[i][k])
        end
        print()
    end
end

local function s2a(s)
    local ns = {}
    for i=1, table.getn(s) do
        local nns={}
        for k = 1, string.len(s[i]) do
            table.insert(nns, string.sub(s[i],k,k))
        end
        table.insert(ns,nns)
    end
    return ns
end

function ca(bg, a, x,y)
    ntb={} lbg=#bg la=#a lax=#a[1] lbgx=#bg[1]
    if lbgx-((lax+y)-1)<0 then
    elseif lbg-((la+x)-1)<0 then
    else
        for i=1,la do
            for j = 1, lax do
                if " "==a[i][j] then
                else
                    table.remove(bg[x+(i-1)],y+(j-1))
                    table.insert(bg[x+(i-1)],y+(j-1), a[i][j])
                end
            end
        end
    end
    return bg
end
f=s2a({" ________________________________________________________________ ","|\\ ____________________________________________________________ /|","| |                                                            | |","| |                                                            | |","| |                                                            | |","| |                                                            | |","| |                                                            | |","| |                                                            | |","| |                                                            | |","| |                                                            | |","| |                                                            | |","| |                                                            | |","| |                                                            | |","| |                                                            | |","| |                                                            | |","| |                                                            | |","| |                                                            | |","| |                                                            | |","| |                                                            | |","| |                                                            | |","| |____________________________________________________________| |","|/______________________________________________________________\\|"})
boat=s2a({"    _    ","   /|\\     ","  / | \\   "," /__|__\\  ","____|____ ","\\_______/  "})
ccc=s2a({"   ___  "," _(   ) ","(___)__)"})
water=s2a({"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"})
tblock=s2a({"xxx","xxx","xxx"})
temp=ca(f,water,19-bh,4)
if hh<18 and hh>= 6 then
    n=bm sb = {{"-",".","-"}}
else
    n=3*bm sb={{"*"}}
end

for i = 1,n do
    r1=math.random(14 -bh)
    r2=math.random(59)
    temp=ca(temp,sb,r1+3,r2+3)
end
if cdw==0 then
else
    for i=1,cdw do
        r1=math.random(11-bh)
        r2=math.random(52)
        temp=ca(temp,ccc,r1+3,r2+3)
    end
end
temp=ca(temp,boat,14-bh, bsm)
tp(temp)

You can take look at it here.

|\ ____________________________________________________________ /|
| |                                                            | |
| |       -.-                                                  | |
| |                                                            | |
| |                                        ___                 | |
| |                                      _(   )                | |
| |                  -.-   -.-          (___)__)               | |
| |                                                            | |
| |                            -.-             _        ___    | |
| |          -.-                              /|\     _(   )   | |
| |              -.-                         / | \   (___)__)  | |
| |                                         /__|__\ -.-.-      | |
| |                                        ____|____           | |
| |~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\_______/~~~~~~~~~~~| |
| |                                                            | |
| |                                                            | |
| |                                                            | |
| |                                                            | |
| |                                                            | |
| |____________________________________________________________| |
|/______________________________________________________________\|

Adding an example output here would be good too (especially for the once a week bit).

authors: กันลยา แสงแดง


text:
Write a "Look-and-Say Numbers" generator
There is a sequence of numbers called the "Look-and-Say Numbers".
Here is an example of the first 5 terms of the sequence, starting at 1 (with spaces added between the digits):
     1
    1 1
    2 1
  1 2 1 1
1 1 1 2 2 1

The pattern is simple, once you see it.
The sequence starts with 1. There is one 1, so the next number is 11 (as in one of the number 1).
In this number, there are 2 1s, so the next number is 21.
In this number there is 1 2, and 1 1, so the next number is 1211.
In this number there is 1 1, followed by 1 2, followed 2 1s - so the number is 111221.
The Task
You must write a program that generates the first n terms of this sequence, where n is given by stdin. The sequence will start at 1.
This is a code-golf task, so shortest code wins.

@Calvin'sHobbies The linked question has an additional restriction, but that restriction is quite trivial in practice. Therefore I am voting to close as a duplicate.

Mathematica, 68 bytes
There's no STDIN in Mathematica, so here is a function instead
s=FromDigits/@NestList[Flatten[Reverse@@@Tally/@Split[#]]&,{1},#-1]&

Usage:
s[5]

> {1, 11, 21, 1211, 111221}

Isn't Input[] STDIN?

@DavidCarraher Well, it's kinda STDIN but parses and interprets the input right away, right?

Good point.  And InputString[] avoids parsing but interprets all input as strings.

source: Stack Exchange

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

sort: votes


text:
is_gaussian_prime(z)?
Task
Write a function that accepts two integers \$a,b\$ that represent the Gaussian integer \$z = a+bi\$ (complex number). The program must return true or false depending on whether \$a+bi\$ is a Gaussian prime or not.
Definition
\$a+bi\$ is a Gaussian prime if and only if it meets one of the following conditions:

\$a\$ and \$b\$ are both nonzero and \$a^2 + b^2\$ is prime
\$a\$ is zero, \$|b|\$ is prime and \$|b| = 3 \text{ (mod }4)\$
\$b\$ is zero, \$|a|\$ is prime and \$|a| = 3 \text{ (mod }4)\$

Details
You should only write a function. If your language does not have functions, you can assume that the integers are stored in two variables and print the result or write it to a file.
You cannot use built-in functions of your language like isprime or prime_list or nthprime or factor. The lowest number of bytes wins. The program must work for \$a,b\$ where \$a^2+b^2\$ is a 32bit (signed) integer and should finish in not significantly more than 30 seconds.
Prime list
The dots represent prime numbers on the Gaussian plane (x = real, y = imaginary axis):

Some larger primes:
(9940, 43833)
(4190, 42741)
(9557, 41412)
(1437, 44090)

Are we allowed to use factorisation functions (factor in Bash, mf and mF in CJam, ...)

Oh no, I forgot those factorizing methods existed, no please not=) And 32bit limit applies to a^2+b^2, would not make sense otherwise. Thank you for your inputs! I updated the question.

I added a definition of Gaussian primes to the post. If you don't like how I've done it, feel free to roll it back, but I would definitely recommend including the definition somewhere.

Thats nice, I originally just didn't want to directly point out how to determine the primality in order for people to get creative=)

1   1073741857 not seems to me a Gaussian prime because
1^2+   1073741857^2 is one even number...

@RosLuP Thanks, I made a mistake, I now added some hopefully correct examples.

$1^2+1026^2=1052677=6117257$, $1^2+1038^2=1077445=5215489$, $2^2+2051^2=4206605=5841321$, $17^2+1778^2=3161573=10133121$ TIO

(9940, 43833), (4190, 42741), (9557, 41412), (1437, 44090) are tested

@AlexeyBurdin Thanks, added!

Haskell - 77/108107 Chars
usage:
in both the solutions, typing a%b will return whether a+bi is a gaussian prime.
the lowest i managed, but no creativity or performance (77 chars)
p n=all(\x->rem n x>0)[2..n-1]
a%0=rem a 4==3&&p(abs a)
0%a=a%0
a%b=p$a^2+b^2

this solution just powers through all numbers below n to check if it's prime.
ungolfed version:
isprime = all (\x -> rem n x != 0) [2..n-1] -- none of the numbers between 2 and n-1 divide n.
isGaussianPrime a 0 = rem a 4==3 && isprime (abs a)
isGaussianPrime 0 a = isGaussianPrime a 0   -- the definition is symmetric
isGaussianPrime a b = isprime (a^2 + b^2)

the next solution has an extra feature - memoization.
once you checked if some integer n is prime, you won't need to recalculate the "primeness" of all numbers smaller than or equal to n, as it will be stored in the computer.
(107 chars. the comments are for clarity)
s(p:x)=p:s[n|n<-x,rem n p>0] --the sieve function
l=s[2..]                     --infinite list of primes
p n=n==filter(>=n)l!!0       --check whether n is in the list of primes
a%0=rem a 4==3&&p(abs a)
0%a=a%0
a%b=p$a*a+b*b

ungolfed version:
primes = sieve [2..] where
    sieve (p:xs) = p:filter (\n -> rem n p /= 0) xs
isprime n = n == head (filter (>=n) primes) -- checks if the first prime >= n is equal to n. if it is, n is prime.
isGaussianPrime a 0 = rem a 4==3 && isprime (abs a)
isGaussianPrime 0 a = isGaussianPrime a 0   -- the definition is symmetric
isGaussianPrime a b = isprime (a^2 + b^2)

this uses the sieve of Eratosthenes to compute an infinite list of all primes (called l for list in the code). (infinite lists are a well known trick of haskell).
how is it possible to have an infinite list?
at the start of the program, the list is unevaluated, and instead of storing the lists elements, the computer stores the way to compute them. but as the program accesses the list it partially evaluates itself up to the request. so, if the program were to request the fourth item in the list, the computer would compute all primes up to the forth that aren't already evaluated, store them, and the rest would remain unevaluated, stored as the way to compute them once needed.
note that all of this is given freely by the lazy nature of the Haskell language, none of that is apparent from the code itself.
both versions of the program are overloaded, so they can handle arbitrarily-sized data.

By my count, your first solution is actually 77 characters :D

i counted newlines, shouldn't i?

I count 74 regular characters and 3 newlines

you're right, it seems that for some reason notepad++ adds characters before newlines. thanks!

that's why I use sublime ;) glad to help!

Also I believe the arguments in your lambda \x->rem x n>0 are reversed. Try rem n x instead

thanks, i haven't caught that because i switched to it from ((\rem`n).(>0))` after running

funny i removed the list comprehension for golfing one more char, as i usually hate them, and added them just for golfing.

@proudhaskeller CRLF much?

are you talking about the character count thing? maybe, i don't know

You can change notepad++ to LF (Unix)

C, 149 118 characters
Edited version (118 characters):
int G(int a,int b){a=abs(a);b=abs(b);int n=a*b?a*a+b*b:a+b,
d=2;for(;n/d/d&&n%d;d++);return n/d/d|n<2?0:(a+b&3)>2|a*b;}

This is a single function:

G(a,b) returns nonzero (true) if a+bi is a Gaussian prime, or zero (false) otherwise.

It folds the integer primality test into an expression n/d/d|n<2 hidden in the return value calculation. This golfed code also makes use of a*b as a substitute for a&&b (in other words a!=0 && b!=0) and other tricks involving operator precedence and integer division. For example n/d/d is a shorter way of saying n/d/d>=1, which is an overflow-safe way of saying n>=d*d or d*d<=n or in essence d<=sqrt(n).

Original version (149 characters):
int Q(int n){int d=2;for(;n/d/d&&n%d;d++);return n/d/d||n<2;}
int G(int a,int b){a=abs(a);b=abs(b);return!((a|b%4<3|Q(b))*(b|a%4<3|Q(a))*Q(a*a+b*b));}

Functions:

Q(n) returns 0 (false) if n is prime, or 1 (true) if n is nonprime. It is a helper function for G(a,b).
G(a,b) returns 1 (true) if a+bi is a Gaussian prime, or 0 (false) otherwise.

Sample output (scaled up 200%) for |a|,|b| ≤ 128:

+1 for the image! Could you also do one about the same size just in the first quadrant (because symmetry), it really looks great here=)

You can save a couple of characters by replacing
d=2;for(;n/d/d&&n%d;d++);
with
for(d=2;n/d/d&&n%d++;);

@Alchymist — That indeed saves characters, but produces incorrect results. It's important that the d++ not happen as part of the condition, else it messes up the logic following. Also, moving the d=2 inside the for loop actually increases the character count rather than decreasing it, because d still needs to be declared as int prior to the for loop. Am I missing something?

Too true.  Perils of looking at this away from a coding environment and not closely enough.  Incrementing has to stay where it is and the initialisation only helps your original solution.  There are obvious savings if you declare  n & d outside the function, without specifying int, and initialise them in the for loop but I assume you are making the function self-contained which is a strict interpretation of the requirements.

The prime-testing loop here is some spectacular golfing! However it is possible to achieve even more savings by dropping the int type specifiers for the return type and arguments, using a variable for |a| + |b| and optimizing the return statement: G(a,b){int s=abs(a)+abs(b),n=a*b?a*a+b*b:s,d=2;for(;n/d/d&&n%d;d++);return n>1>n/d/d&&s%4/3|a*b;} comes out to just 97 characters.

Can't you leave out the ints?

@feersum — Good lord, that's clever...especially the n>1>n/d/d. I just finally now saw this and haven't fully wrapped my mind around it. Will study. Thanks!

APL (Dyalog Unicode), 36 47 48 49 47 43 28 bytes
Takes an array of two integers a b and returns the Boolean value of the statement a+bi is a Gaussian integer.
Edit: +11 bytes because I misunderstood the definition of a Gaussian prime. +1 byte from correcting the answer again. +1 byte from a third bug fix. -2 bytes due to using a train instead of a dfn. -4 bytes thanks to ngn due to using a guard condition: if_true ⋄ if_false instead of if_true⊣⍣condition⊢if_false. -15 bytes thanks to ngn due to finding a completely different way to write the condition-if-else as a full train.
{2=≢∪⍵∨⍳⍵}|+.×0∘∊⊃|{⍺⍵}3=4||

Try it online!
Explanation
{2=≢∪⍵∨⍳⍵}|+.×0∘∊⊃|{⍺⍵}3=4||

                           |  ⍝ abs(a), abs(b) or abs(list)
                       3=4|   ⍝ Check if a and b are congruent to 3 (mod 4)
                  |{⍺⍵}       ⍝ Combine with (abs(a), abs(b))
              0∘∊⊃            ⍝ Pick out the original abs(list) if both are non-zero
                              ⍝ Else pick out (if 3 mod 4)
          |+.×                ⍝ Dot product with abs(list) returns any of
                              ⍝ - All zeroes if neither check passed
                              ⍝ - The zero and the number that IS 3 mod 4
                              ⍝ - a^2 + b^2
{2=≢∪⍵∨⍳⍵}                    ⍝ Check if any of the above are prime, and return

Haskell -- 121 chars (newlines included)
Here's a relatively simple Haskell solution that doesn't use any external modules and is golfed down as much as I could get it.
a%1=[]
a%n|n`mod`a<1=a:2%(n`div`a)|1>0=(a+1)%n
0#b=2%d==[d]&&d`mod`4==3where d=abs(b)
a#0=0#a
a#b=2%c==[c]where c=a^2+b^2

Invoke as ghci ./gprimes.hs and then you can use it in the interactive shell. Note: negative numbers are finicky and must be placed in parentheses. I.e.
*Main>1#1
True
*Main>(-3)#0
True
*Main>2#2
False

Python - 121 120 chars
def p(x,s=2):
 while s*s<=abs(x):yield x%s;s+=1
f=lambda a,b:(all(p(a*a+b*b))if b else f(b,a))if a else(b%4>2)&all(p(b))

p checks whether abs(x) is prime by iterating over all numbers from 2 to abs(x)**.5 (which is sqrt(abs(x))). It does so by yielding x % s for each s. all then checks whether all the yielded values are non-zero and stops generating values once it encounters a divisor of x. In f, f(b,a) replaces the case for b==0, inspired by @killmous' Haskell answer.

-1 char and bugfix from @PeterTaylor

Glad I could help :)

You could replace s<abs(x)**.5 with s*s<abs(x) for a saving of 2. Although really you should be checking <=, so it's probably buggy at present.

@PeterTaylor Thank you for pointing out the bug...

Calling f(0,15) yields TypeError: unsupported operand type(s) for &: 'bool' and 'generator' with my interpreter. :(

f(0,15) gives False for me, both on 2.7.6 and 3.4.1 (on OS X). What version are you on?

Python 2.7.8, OS X 10.9.4. Strange... Here it is working.

Python 2.7, 341 301 253 bytes, optimized for speed
lambda x,y:(x==0and g(y))or(y==0and g(x))or(x*y and p(x*x+y*y))
def p(n,r=[2]):a=lambda n:r+range(r[-1],int(n**.5)+1);r+=[i for i in a(n)if all(i%j for j in a(i))]if n>r[-1]**2else[];return all(n%i for i in r if i*i<n)
g=lambda x:abs(x)%4>2and p(abs(x))

Try it online!
#pRimes. need at least one for r[-1]
r=[2]
#list of primes and other to-check-for-primarity numbers
#(between max(r) and sqrt(n))
a=lambda n:r+list(range(r[-1],int(n**.5)+1))
#is_prime, using a(n)
f=lambda n:all(n%i for i in a(n))
#is_prime, using r
def p(n):
    global r
    #if r is not enough, update r
    if n>r[-1]**2:
        r+=[i for i in a(n) if f(i)]
    return all(n%i for i in r if i*i<n)
#sub-function for testing (0,y) and (x,0)
g=lambda x:abs(x)%4==3 and p(abs(x))
#the testing function
h=lambda x,y:(x==0 and g(y)) or (y==0 and g(x)) or (x and y and p(x*x+y*y))

Thanks: 40+48 -- entire golfing to
Jo King

The f lambda is also uneccesary, along with the list call. 257 bytes without those, plus some whitespace removal. This perhaps isn't as efficient anymore though

(15,0) is now true in 257 bytes version and the run time increased too 5.5s, sorry

Perl - 110 107 105 chars
I hope I followed the linked definition correctly...
sub f{($a,$b)=map abs,@_;$n=$a**(1+!!$b)+$b**(1+!!$a);(grep{$n%$_<1}2..$n)<2&&($a||$b%4>2)&&($b||$a%4>2)}

Ungolfed:
sub f {
  ($a,$b) = map abs, @_;
  $n = $a**(1+!!$b) + $b**(1+!!$a);
  (grep {$n%$_<1} 2..$n)<2 && ($a || $b%4==3) && ($b || $a%4==3)
}

Explanation, because someone asked: I read the arguments (@_) and put their absolute values into $a,$b, because the function does not need their sign. Each of the criteria requires testing a number's primality, but this number depends on whether $a or $b are zero, which I tried to express in the shortest way and put in $n. Finally I check whether $n is prime by counting how many numbers between 2 and itself divide it without a remainder (that's the grep...<2 part), and then check in addition that if one of the numbers is zero then the other one equals 3 modulo 4. The function's return value is by default the value of its last line, and these conditions return some truthy value if all conditions were met.

I can't get it to work for negative parameters.

@killmous you're right, just fixed it

may you explain the algorithm?

Nice! By the way, I think you could shave off a couple characters by writing $a%4>2 instead of $a%4==3.

golflua 147 141
The above count neglects the newlines that I've added to see the different functions. Despite the insistence to not do so, I brute-force solve primes within the cases.
\p(x)s=2@s*s<=M.a(x)?(x%s==0)~0$s=s+1$~1$
\g(a,b)?a*b!=0~p(a^2+b^2)??a==0~p(b)+M.a(b)%4>2??b==0~p(a)+M.a(a)%4>2!?~0$$
w(g(tn(I.r()),tn(I.r())))

Returns 1 if true and 0 if not.
An ungolfed Lua version,
-- prime number checker
function p(x)
   s=2
   while s*s<=math.abs(x) do
      if(x%s==0) then return 0 end
      s=s+1
   end
   return 1
end

-- check gaussian primes
function g(a,b)
   if a*b~=0 then
      return p(a^2+b^2)
   elseif a==0 then
      return p(b) + math.abs(b)%4>2
   elseif b==0 then
      return p(a) + math.abs(a)%4>2
   else
      return 0
   end
end

a=tonumber(io.read())
b=tonumber(io.read())
print(g(a,b))

You can save 6 characters by just plugging tonumber(io.read()) as an argument to g in the end,  and 2 more by removing the newlines

@mniip: the newlines were not counted, I just added those in for clarity (no sideways scrolling). I'll update the read in g when I get into work in a little bit. Thanks!

Well does it still work in a reasonable amout of time for large numbers? I primarly thought about bruteforcing in the way of checking all gaussian integers a where |a| <= |z| if a | z (if a divides z).

@flawr: I tested it with a=2147483644, b=896234511 and got 0 in about 0.002 s. I also tested it with 2147483629 & 2147483587 (two very large primes) and got 0 in another 0.002 s. I'm trying to find a large pair of numbers such that a^2+b^2 is prime & ensure that I've got a working solution for such large numbers.

@flawr: Tested with a=4600 & b=5603 (a^2+b^2=2147393609 is prime & < 2^32-1) and it took the same 0.002 seconds to return 1. Yay!

Guess this dialect of Lua never caught on. Too bad.

APL(NARS), 99 chars, 198 bytes
r←p w;i;k
r←0⋄→0×⍳w<2⋄i←2⋄k←√w⋄→3
→0×⍳0=i∣w⋄i+←1
→2×⍳i≤k
r←1

f←{v←√k←+/2*⍨⍺⍵⋄0=⍺×⍵:(p v)∧3=4∣v⋄p k}

test:
  0 f 13
0
  0 f 9
0
  2 f 3
1
  3 f 4
0
  0 f 7
1
  0 f 9
0
  4600 f 5603
1

Runic Enchantments, 41 bytes
>ii:0)?\S:0)?\:*S:*+'PA@
3%4A|'S/;$=?4/?3

Try it online!
Ended up being a lot easier than I thought and wasn't much room for golfification. The original program I blocked out was:
>ii:0)?\S:0)?\:*S:*+'PA@
3%4A|'S/!   S/;$=

I played around with trying to compare both inputs at the same time (which saved all of one 1 byte), but when that drops into the "one of them is zero" section, there wasn't a good way to figure out which item was non-zero in order to perform the last check, much less a way to do it without spending at least 1 byte (no overall savings).

Mathematica, 149 Characters
If[a==0,#[[3]]&&Mod[Abs@b,4]==3,If[b==0,#[[2]]&&Mod[Abs@a,4]==3,#[[1]]]]&[(q=#;Total[Boole@IntegerQ[q/#]&/@Range@q]<3&&q!=0)&/@{a^2+b^2,Abs@a,Abs@b}]

The code doesn't use any standard prime number features of mathematica, instead it counts the number of integers in the list {n/1,n/2,...,n/n}; if the number is 1 or 2, then n is prime. An elaborated form of the function:
MyIsPrime[p_] := (q = Abs@p;
  Total[Boole@IntegerQ[q/#] & /@ Range@q] < 3 && q != 0)

Bonus plot of all the Gaussian Primes from -20 to 20:

Ruby -rprime, 65 60 80 bytes
Didn't notice the "can't use isPrime" rule...
->a,b{r=->n{(2...n).all?{|i|n%i>0}};c=(a+b).abs;r[a*a+b*b]||a*b==0&&r[c]&&c%4>2}

Try it online!

Uiua, 24 bytes
=1/+=0◿⇡./+×⍥(=3◿4)∊0..⌵

Try it online!
Straightforward implementation of the condition described on the Mathworld page.
=1/+=0◿⇡./+×⍥(=3◿4)∊0..⌵   input: a 2-element vector [a b] representing a+bi
                         ⌵   absolute value of each
             ⍥(    )∊0..    on a copy of it, if it contains 0,
                =3◿4        change it to v%4==3
          /+×                elementwise multiply and sum
                             (gives a^2+b^2 if ab!=0, a or b if it is 3 mod 4 and
                             the other is 0, 0 otherwise)
=1/+=0◿⇡.                    primality test

JavaScript (Node.js), 78 bytes
a=>b=>P(a*a+b*b)|Math.abs(z=a?a*!b:b)%4+P(z)>3
P=(n,k=2)=>k*k>n||n%k&&P(n,k+1)

Try it online!
JavaScript (Node.js), 93 bytes, slow
p=>q=>8==(g=(a,b,c,d)=>(a+n&&g(a-1,b,c,d))+(1/d?a*c-b*d==p&a*d+b*c==q:g(n,a,b,c)))(n=p*p+q*q)

Try it online!
Modified from vanilla definition of Gaussian prime: there's exactly 8 pairs of complex <x,y>, s.t. x*y=input

Vyxal, 136 bitsv2, 17 bytes
⋏A[|ȧ:4%3=]Þ•:‹¡›$%¬

Try it Online!
Bitstring:
1100111001011011010111100100111010100100001111100100100011010011110001011011001001101101100000000000111110011101010011001000101011000001

Literal interpretation of mathworld

Python - 117 122 121
def f(a,b):
 v=(a**2+b**2,a+b)[a*b==0]
 for i in range(2,abs(v)):
  if v%i<1:a=b=0
 return abs((a,b)[a==0])%4==3or a*b!=0

Because 3 is the largest a number can be mod 4, you could replace the ==3 with >2

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

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


text:
Output Graham's Number
Write a program that outputs all 64 layers of this representation of Graham's number from Wikipedia:

Your output must exactly match this ASCII version (in which ^ represents Knuth's up-arrows and combinations of slashes and underscores represent the large horizontal curly brackets):
3^^...............................................................................................................................^3
 \_______________________________________________________________  _______________________________________________________________/
                                                                 \/
 3^^.............................................................................................................................^3
  \______________________________________________________________  ______________________________________________________________/
                                                                 \/
  3^^...........................................................................................................................^3
   \_____________________________________________________________  _____________________________________________________________/
                                                                 \/
   3^^.........................................................................................................................^3
    \____________________________________________________________  ____________________________________________________________/
                                                                 \/
    3^^.......................................................................................................................^3
     \___________________________________________________________  ___________________________________________________________/
                                                                 \/
     3^^.....................................................................................................................^3
      \__________________________________________________________  __________________________________________________________/
                                                                 \/
      3^^...................................................................................................................^3
       \_________________________________________________________  _________________________________________________________/
                                                                 \/
       3^^.................................................................................................................^3
        \________________________________________________________  ________________________________________________________/
                                                                 \/
        3^^...............................................................................................................^3
         \_______________________________________________________  _______________________________________________________/
                                                                 \/
         3^^.............................................................................................................^3
          \______________________________________________________  ______________________________________________________/
                                                                 \/
          3^^...........................................................................................................^3
           \_____________________________________________________  _____________________________________________________/
                                                                 \/
           3^^.........................................................................................................^3
            \____________________________________________________  ____________________________________________________/
                                                                 \/
            3^^.......................................................................................................^3
             \___________________________________________________  ___________________________________________________/
                                                                 \/
             3^^.....................................................................................................^3
              \__________________________________________________  __________________________________________________/
                                                                 \/
              3^^...................................................................................................^3
               \_________________________________________________  _________________________________________________/
                                                                 \/
               3^^.................................................................................................^3
                \________________________________________________  ________________________________________________/
                                                                 \/
                3^^...............................................................................................^3
                 \_______________________________________________  _______________________________________________/
                                                                 \/
                 3^^.............................................................................................^3
                  \______________________________________________  ______________________________________________/
                                                                 \/
                  3^^...........................................................................................^3
                   \_____________________________________________  _____________________________________________/
                                                                 \/
                   3^^.........................................................................................^3
                    \____________________________________________  ____________________________________________/
                                                                 \/
                    3^^.......................................................................................^3
                     \___________________________________________  ___________________________________________/
                                                                 \/
                     3^^.....................................................................................^3
                      \__________________________________________  __________________________________________/
                                                                 \/
                      3^^...................................................................................^3
                       \_________________________________________  _________________________________________/
                                                                 \/
                       3^^.................................................................................^3
                        \________________________________________  ________________________________________/
                                                                 \/
                        3^^...............................................................................^3
                         \_______________________________________  _______________________________________/
                                                                 \/
                         3^^.............................................................................^3
                          \______________________________________  ______________________________________/
                                                                 \/
                          3^^...........................................................................^3
                           \_____________________________________  _____________________________________/
                                                                 \/
                           3^^.........................................................................^3
                            \____________________________________  ____________________________________/
                                                                 \/
                            3^^.......................................................................^3
                             \___________________________________  ___________________________________/
                                                                 \/
                             3^^.....................................................................^3
                              \__________________________________  __________________________________/
                                                                 \/
                              3^^...................................................................^3
                               \_________________________________  _________________________________/
                                                                 \/
                               3^^.................................................................^3
                                \________________________________  ________________________________/
                                                                 \/
                                3^^...............................................................^3
                                 \_______________________________  _______________________________/
                                                                 \/
                                 3^^.............................................................^3
                                  \______________________________  ______________________________/
                                                                 \/
                                  3^^...........................................................^3
                                   \_____________________________  _____________________________/
                                                                 \/
                                   3^^.........................................................^3
                                    \____________________________  ____________________________/
                                                                 \/
                                    3^^.......................................................^3
                                     \___________________________  ___________________________/
                                                                 \/
                                     3^^.....................................................^3
                                      \__________________________  __________________________/
                                                                 \/
                                      3^^...................................................^3
                                       \_________________________  _________________________/
                                                                 \/
                                       3^^.................................................^3
                                        \________________________  ________________________/
                                                                 \/
                                        3^^...............................................^3
                                         \_______________________  _______________________/
                                                                 \/
                                         3^^.............................................^3
                                          \______________________  ______________________/
                                                                 \/
                                          3^^...........................................^3
                                           \_____________________  _____________________/
                                                                 \/
                                           3^^.........................................^3
                                            \____________________  ____________________/
                                                                 \/
                                            3^^.......................................^3
                                             \___________________  ___________________/
                                                                 \/
                                             3^^.....................................^3
                                              \__________________  __________________/
                                                                 \/
                                              3^^...................................^3
                                               \_________________  _________________/
                                                                 \/
                                               3^^.................................^3
                                                \________________  ________________/
                                                                 \/
                                                3^^...............................^3
                                                 \_______________  _______________/
                                                                 \/
                                                 3^^.............................^3
                                                  \______________  ______________/
                                                                 \/
                                                  3^^...........................^3
                                                   \_____________  _____________/
                                                                 \/
                                                   3^^.........................^3
                                                    \____________  ____________/
                                                                 \/
                                                    3^^.......................^3
                                                     \___________  ___________/
                                                                 \/
                                                     3^^.....................^3
                                                      \__________  __________/
                                                                 \/
                                                      3^^...................^3
                                                       \_________  _________/
                                                                 \/
                                                       3^^.................^3
                                                        \________  ________/
                                                                 \/
                                                        3^^...............^3
                                                         \_______  _______/
                                                                 \/
                                                         3^^.............^3
                                                          \______  ______/
                                                                 \/
                                                          3^^...........^3
                                                           \_____  _____/
                                                                 \/
                                                           3^^.........^3
                                                            \____  ____/
                                                                 \/
                                                            3^^.......^3
                                                             \___  ___/
                                                                 \/
                                                             3^^.....^3
                                                              \__  __/
                                                                 \/
                                                              3^^...^3
                                                               \_  _/
                                                                 \/
                                                               3^^^^3

Notice that there are 64 layers, that there are no trailing spaces, and that two ^ occur before the dots and only one occurs after.
The MD5 hash of your output should precisely be c84d0e20eac2a7f891ab42a8eb77759f, or 1ad3b10d06e38693436c14958b2c47a8 if there is a trailing newline (which is ok).
The shortest code in bytes wins. Output to stdout. There is no input.

Why are they dots and not more up-arrows? I'm pretty sure the purpose of the ellipses in the picture was just to show the missing arrows.

@raptortech97 Because there's a LOT of missing arrows. Graham's number is bloody massive. I'm hnonestly curious to see what languages can actually handle it.

The ellipses represent numbers of arrows that aren't even representable without using up-arrow notation

Ah... yeah I just read the Wikipedia page and I get it now.

@fuandon You won't get any language to actually compute the number, even if you allowed for a universe sized computer, it's just plain too big.
I suppose you could calculate an arbitrarily large amount the rightmost digits, but that just isn't the same.

Would this be considered [tag:ascii-art]?

It might be worth giving out the MD5 hashes for quick verification: 1ad3b10d06e38693436c14958b2c47a8 as given by grc, or c84d0e20eac2a7f891ab42a8eb77759f if the final newline character can be omitted.

I believe Graham's number requires more electrons than exists in the universe to represent in binary therefore languages like Tcl and Ruby can do it in theory because the specifications of the language doesn't limit the size of integers but practically you'd run out of RAM.

Of course, the much more interesting task of actually computing Graham's number (assuming super-naturally memory resources etc.) has been covered elsewhere already.

I am a bit disappointed with the expected output. Would be a nicer challenge, if the program was expected to output the actual number. As @slebetman pointed out, there are languages, which could do it. (Implementation limitations prevent the program from actually running to completion, but the program can still be written, and sizes can be compared.)

@kasperd There is already a challenge like that.

CJam - 64
63{SI*3'^_'._63I-:J*_'^3NSI)*'\'_J*_S_@'/NS65*"\/
"}fIS63*3'^4*3

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

Python, 122
i=63
while i:
 for s in'3^^'+'..'*i+'.^3','\%s  %s/'%(('_'*i,)*2),'\/':print' '*(66-len(s)/2)+s
 i-=1
print' '*63+'3^^^^3'

Example:
$ python grahams.py | md5
1ad3b10d06e38693436c14958b2c47a8

What does that output mean?

It means he didn't want to spam the answers with a reproduction of the huge ascii output above, I think.

Ah, fair enough. I get it now, result was hashed.

Nice replacement of a for loop with a while loop.

Perl -- 113 (112 + 1 for -E)

Golfed:
$.=$"x63,$y="_"x($!=63-$_),$x.=($z=$"x$_)."3^^".".."x$!.".^3$/ $z\\$y  $y/$/ $. \\/$/"for 0..62;say"$x$.3^^^^3"

Ungolfed:
for(0..62) {
    $.=$"x63;
    $!=63-$_;
    $y="_"x$_;
    $z=$"x$!;
    $x.=$z."3^^".".."x$!.".^3$/ $z\\$y  $y/$/ $. \\/$/";
}
say"$x$.3^^^^3"

EDIT: There was an error in string interpolation where perl thought $m3 was a variable, so I had to add 2 characters to fix that. Solved by changing $m to $.
NINJA EDIT: Replaced instances of " " with $". Saves 2 characters
NINJA EDIT 2: Thanks @chilemagic for pointing out that I can use say instead of print with -E to save a character.
NOT-SO-NINJA EDIT 3: @Nax's solution beat my old solution, so I buffed it up a little to hold its ground.

I was literally just about to post a Perl answer (a few characters longer, though) when yours shifted the page down. I like how you used $m inside and outside the loop to reduce the redundancy.

You can use say instead of print and then run it with -E instead of -e (if your Perl version is high enough). Looks great though!

Haskell, 152
(?)=replicate
g 0=["3^^^^3"]
g i=("3^^"++(i*2)?'.'++".^3"):map(' ':)(("\\"++i?'_'++"  "++i?'_'++"/"):((i+1)?' '++"\\/"):g(i-1))
main=putStr.unlines.g$63

Damn it! That's twice I've been ninja'd by seconds. I think I might save you a character, though, if you remove +1 and just add the dot before "^3".

@comperendinous Good point, thanks.

You can replace "\"++ with '\':

C 161 182
(i think i maxed out this method, maybe i should find a new one that can be golfed down more)
compile as C99!
main(i){for(char d[]={[0 ...126]=46,i=0},l[]={[0 ...62]=95,0};i<63;)printf("3^^%s^3\n%*s\\%s  %s/\n%*s\n%*s",d+2*i++,i,"",l+i,l+i,67,"\\/",i,"");puts("3^^^^3");}

JS 158
r="repeat";o="";u="_";s=" ";(f=i=>i?"3^^"+"."[r](i*2+1)+"^3\n"+s[r](64-i)+"\\"+u[r](i)+s[r](2)+u[r](i)+"/\n"+s[r](65)+"\\/\n"+s[r](64-i)+f(i-1):"3^^^^3")(63);

xem.github.io/obfuscatweet/ 124:
eval(unescape(escape('').replace(/uD./g,'')))

Bash+coreutils, 150
I thought I might be able to do better than this.  Oh well.
r()(yes "${2:- }"|head -$[$1]|tr -d '
')
for i in {63..1};{
r 63-$i
echo "3^^`r 2*$i .`.^3
`r 64-$i`\\`r $i _`  `r $i _`/
`r 65`\/"
}
r 63
echo 3^^^^3

Output:
$ ./graham.sh | md5sum
1ad3b10d06e38693436c14958b2c47a8  -
$

Perl, 116 112 109 108 (including -E)
My first attempt at golfing. Please take it as such:
Golfed:
perl -E'map{$_=" $_!^".(($b=63-$_)?"2.$b.$b.^!
 $_ \\_$b 2_$b/
 65\\/":"4!");s#(.)(\d+)#"$1"x$2#eg;y/!/3/;say}0..63'

Very slightly ungolfed (not maintained ... ):
map
{
    $b = 63 - $_;
    $_ = " $_!^".($b
        ? "2.$b.$b.^!N $_ \\_$b 2_$b/N 65\\/"
        : "4!");
    s#(.)(\d+)#"$1"x$2#eg;    # behaves exactly as $_ =~ s/(.)(\d+)/"$1"x$2/eg
    y/!N/3\n/;                  # y == tr, so this does $_ =~ tr/!N/3\n/
    say;                        # once more $_ completion, this does say $_ == print "$_\n"
} (0..63);

Essentially it works like this: for each line of 3s and a brace (these are handled together), it writes their sequence RLE-encoded, then decodes it. The rule is simple: every char followed by a number is expanded to that char that number of times. Characters without a number are left alone. Finally, the character ! denotes a 3 and a N means a newline (3 had to be encoded because it is number and would eagerly participate as the number of repetitions).
Each line of 3s and its brace get an element in the 64-element array the map is generating. Say, like print, can output arrays -- if given an array, it prints all the elements (without any separators).
I used chilemagic's trick with -E. Thanks for it.
Reinforcements: Two 113 byte solutions started to lurk here. RLE shall not succumb without fight!
Cleansing of Feeds: I have now realized that I have no need for a special transliteration of \n, because all strings in Perl are automagically multiple-lined! Thus RLE clings nearer to the Ruby's back! Now at 109 bytes.
Agonizing Enlightment: To count characters properly is harder than I thought. After some struggling, I settled on echo $((wc -c <<<'golf'-1)) (-1, because it counts a LF at the very end of the script). Moreover I have rearranged my assignments and saved 1 character, hereby settling on 108 bytes.

STATA 135
forv x=63(-1)1{
di _d(63-`x')" ""3^^"_d(2*`x'+1)".""^3"_n_d(64-`x')" ""\"_d(`x')"_""  "_d(`x')"_"_n-d(65)" ""\/"
}
di _d(63)"3^^^^3"

JavaScript 179
n='';a=Array;for(b=64;b>1;)n+=(c=a(65-b).join(' '))+'3^^'+a(2*b).join('.')+'^3\n'+c+' \\'+(u=a(b--).join('_'))+'  '+u+'/\n'+(d=a(64).join(' '))+'  \\/\n'
console.log(n+d+'3^^^^3')

Test it in your browser console or at http://jsfiddle.net/2qwvrvcw/.

Javascript (203)
u="_";s=" ";for(i=64;i>1;i--)console.log(s.repeat(64-i)+"3^^"+".".repeat(i*2-1)+"^3\n"+s.repeat(64-i)+"\\"+u.repeat(i)+s.repeat(2)+u.repeat(i)+"/\n"+s.repeat(65)+"\\/");console.log(s.repeat(63)+"3^^^^3")

Ungolfed:
underscore = "_";
space = " ";
for (i = 64; i > 1; i--) console.log(space.repeat(64 - i) + "3^^" + ".".repeat(i * 2 - 1) + "^3\n" +
                                     space.repeat(64-i) + "\\" + underscore.repeat(i) + space.repeat(2) + underscore.repeat(i) + "/\n" +
                                     space.repeat(65) + "\\/");
console.log(space.repeat(63) + "3^^^^3");

C# (212211)
using C=System.Console;class P{static void Main(){for(int i=64;i>1;)C.Write(@"{0}3^^{2}.^3
{0} \{1}  {1}/
{3,65}\/
",new string(' ',64-i),new string('_',--i),new string('.',i*2),"");C.Write("{0,69}","3^^^^3");}}

.Net Fiddle (it seems to require that the class and Main method are public)
Slightly ungolfed:
using C = System.Console;
class Program {
  static void Main() {
    for (int i = 64; i > 1; ) {
      C.Write("{0}3^^{2}.^3\n{0} \\{1}  {1}/\n{3,65}\\/\n",
 new string(' ', 64 - i),
 new string('_', --i),
 new string('.', i * 2), "");
    }
    C.Write("{0,69}", "3^^^^3");
  }
}

PHP 214
Thought I was doing alright until I counted the characters, anyway here it is -
<?function a($n,$v=" "){for($j=0;$j<$n;$j++){$r.=$v;}return $r;}for($i=64;$i>1;$i--){$b=a($i-1,"_");$v.=a(64-$i)."3^^".a($i*2-1,".")."^3\n".a(64-$i+1)."\\".$b.a(2).$b."/\n".a(65)."\/\n";}$v.=a(63)."3^^^^3";echo $v;

Only changing the output to console you can save up to 11 characters ( ->' ', <br>->\n)

Also, you must add <? at the start of the code - it must be a valid program, not a function.

Ah right thanks, and the tips you suggested, I was basing mine off the page output as opposed to the source code, (/n won't break the line and two ' ' next to each other still make only 1 space), so I guess the source code should be fine too :)

Golfed down to 194 chars: <?function a($n,$v=" "){return str_repeat($v, $n);}for($i=64;$i>1;){$b=a($i-1,"_");$v.=a(64-$i)."3^^".a($i*2-1,".")."^3\n".a(65-$i--)."\\$b".a(2)."$b/\n".a(65)."\/\n";}$v.=a(63)."3^^^^3";echo$v;

md5 check: php grahams.php | md5sum : c84d0e20eac2a7f891ab42a8eb77759f  -

Another tip to your current code - ?> at the end is unnecessary.

Ah thanks a lot for all the help, also I meant to say thanks to your two comments before but forgot to hit submit

MATLAB (325)
m=127:-2:0;n=0:63;p='UniformOutput';q=false;f=@ones;g=@arrayfun;a=g(@(x,y)[f(1,y)*' '  '3^^' f(1,x)*'.'  '^3'],m,n,p,q);b=g(@(x,y)[f(1,y+1)*' '  '\' f(1,(x-1)/2)*'_' '  ' f(1,(x-1)/2)*'_' '/'],m,n,p,q);a{64}(a{64}=='.')='^';g(@(x,y)fprintf('%s\n%s\n%s\n',x{:},y{:},[f(1,65)*' ' '\/']),a,b),fprintf(repmat('\b',1,137))

ungolfed:
m=127:-2:0;
n=0:63;
p='UniformOutput';
q=false;
f=@ones;
g=@arrayfun;
a=g(@(x,y)[f(1,y)*' '  '3^^' f(1,x)*'.'  '^3'],m,n,p,q);
b=g(@(x,y)[f(1,y+1)*' '  '\' f(1,(x-1)/2)*'_' '  ' f(1,(x-1)/2)*'_' '/'],m,n,p,q);
a{64}(a{64}=='.')='^';
g(@(x,y)fprintf('%s\n%s\n%s\n',x{:},y{:},[f(1,65)*' ' '\/']),a,b),fprintf(repmat('\b',1,137))

MATLAB (252)
n=0;f=@ones;g=@arrayfun;for i=127:-2:0 if n~=63 y=f(1,i)*'.';else y='^';z='';end;fprintf('%s\n%s\n%s\n',[f(1,n)*' '  '3^^' y  '^3'],[f(1,n+1)*' '  '\' f(1,(i-1)/2)*'_' '  ' f(1,(i-1)/2)*'_' '/'],[f(1,65)*' ' '\/']);n=n+1;end;fprintf(repmat('\b',1,137))

ungolfed:
n=0;
f=@ones;
g=@arrayfun;
for i=127:-2:0
    if n~=63
        y=f(1,i)*'.';
    else y='^';
        z='';
    end
    fprintf('%s\n%s\n%s\n',[f(1,n)*' '  '3^^' y  '^3'],[f(1,n+1)*' '  '\' f(1,(i-1)/2)*'_' '  ' f(1,(i-1)/2)*'_' '/'],[f(1,65)*' ' '\/']);
    n=n+1;
end
fprintf(repmat('\b',1,137))

Lua - 174
p=print a=" "b="_"for i=0,62 do j=63-i p(a:rep(i).."3^^."..(".."):rep(j).."^3")p(a:rep(i+1).."\\"..b:rep(j).."  "..b:rep(j).."/")p(a:rep(65).."\\/")end p(a:rep(63).."3^^^^3")

Before that, I got two algorithmically different solutions (both 182 !) :
a=" "b="_"for i=0,62 do j=63-i print(a:rep(i).."3^^."..(".."):rep(j).."^3")print(a:rep(i+1).."\\"..b:rep(j).."  "..b:rep(j).."/")print(a:rep(65).."\\/")end print(a:rep(63).."3^^^^3")

a=" "b="_"i=63 while i>0 do c=b:rep(i/2)for _,s in pairs{"3^^."..(".."):rep(i/2).."^3","\\"..c.."  "..c.."/","\\/"}do print(a:rep(66-#s/2)..s)i=i-1 end end print(a:rep(63).."3^^^^3")