text:
This is my pillow
...will you help me immortalize it?

I've had this pillow a few years now, and apparently it's time to get rid of it. Can you please write a function or program, that I can bring with me and use to recreate this pillow whenever I want to reminisce a bit.
It must work with no input arguments.
The output should look exactly like this (trailing newlines and spaces are OK).
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////

This is code golf, so the shortest code in bytes win!

Leaderboard

var QUESTION_ID=98701,OVERRIDE_USER=31516;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="
"+e.body.replace(OVERRIDE_REG,"")+"
")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}
 <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">

Leaderboard

	Author	Language	Size

Winners by Language

Language	User	Score

{{PLACE}}	{{NAME}}	{{LANGUAGE}}	{{SIZE}}	Link

{{LANGUAGE}}	{{NAME}}	{{SIZE}}	Link

I'm somewhat disappointed that the pattern isn't a little more complex, to represent the different line thicknesses of the pillow.

@Sparr I tried, but I didn't manage to make it look good using only ASCII characters. Figured this was close enough :)

I'd have just added spaces

'apparently' :P

Now you can buy a blank pillow and print the winner snippet on it.

@coredump Nah, I wouldn't  like to have an 05AB1E pillow, better do its output... except if it was 05AB1E for "Good night, good sleep."

Related: Make me a blanket!

05AB1E, 18 15 bytes
Code:
„/\5×{4Å6×»6F=R

Explanation:
„/\               # Push the string "/\"
   5×             # Repeat 5 times: "/\/\/\/\/\"
     {            # Sort, resulting in: "/////\\\\\"
      4Å6         # Create a list of 6's with length 4: [6, 6, 6, 6]
         ×        # Vectorized string multiplication
          »       # Join by newlines
           6F     # Do the following six times..
             =    #   Print with a newline without popping
              R   #   Reverse the string

Uses the CP-1252 encoding. Try it online!

Wow... two different takes, same byte count...

///, 116 bytes
/a/\\\\\\\\\\\\\\\///b/\\\\\\\\\\\\\\\\//A/aaaaa//B/bbbbb//C/ABABABABABAB
//D/BABABABABABA
/CCCCDDDDCCCCDDDDCCCCDDDD

Try it online!
Edit: the \\\\\\\\\\\\\\\/ and \\\\\\\\\\\\\\\\ are actually a single / and \, respectively.
Edit: -3 because I thought of removing i. I think this can't be further golfed.

Language name fits quite well

Python 2, 49 bytes
b,a='\/';exec("print(a*5+b*5)*6;"*4+"a,b=b,a;")*6

Thanks to Mitch Schwartz for this clean method that saves a byte. The idea is to print four lines of ('\\'*5+'/'*5)*6, swap the roles of slash and backslash, and then do that whole process 6 times. The two characters are stored in a and b, and swapped as a,b=b,a. The double-loop is double by generating the following code string, then executing it with exec:
print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;a,b=b,a;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;a,b=b,a;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;a,b=b,a;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;a,b=b,a;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;a,b=b,a;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;a,b=b,a;

50 bytes:
s='/'*5+'\\'*5;exec("print s*6;"*4+"s=s[::-1];")*6

Makes the line string, prints it four times and then reverses it, then does that 6 times. Does so by generating the following code, then executing it:
print s*6;print s*6;print s*6;print s*6;s=s[::-1];print s*6;print s*6;print s*6;print s*6;s=s[::-1];print s*6;print s*6;print s*6;print s*6;s=s[::-1];print s*6;print s*6;print s*6;print s*6;s=s[::-1];print s*6;print s*6;print s*6;print s*6;s=s[::-1];print s*6;print s*6;print s*6;print s*6;s=s[::-1]

Here are some of the iterations of my golfing:
for c in([1]*4+[-1]*4)*3:print('/'*5+'\\'*5)[::c]*6

for i in range(24):print('/\\'*5+'\/'*5)[i/4%2::2]*6

for c in range(24):print('\\'*5+'/'*5)[::(c&4)/2-1]*6

for i in range(24):print('/'*5+'\\'*5)[::1-i/4%2*2]*6

for c in([1]*4+[0]*4)*3:print('\/'*5+'/\\'*5)[c::2]*6

for c in([1]*4+[0]*4)*3:print('\/'[c]*5+'/\\'[c]*5)*6

for c in(['/\\']*4+['\/']*4)*3:print(c[0]*5+c[1]*5)*6

for c in([5]*4+[-5]*4)*3:print('/'*c+'\\'*5+'/'*-c)*6

print((('/'*5+'\\'*5)*6+'\n')*4+(('\\'*5+'/'*5)*6+'\n')*4)*3

for x in(['/'*5+'\\'*5]*4+['\\'*5+'/'*5]*4)*3:print x*6

a='/'*5;b='\\'*5
for x in([a+b]*4+[b+a]*4)*3:print x*6

s='/'*5+'\\'*5
for x in([s]*4+[s[::-1]]*4)*3:print x*6

s=('/'*5+'\\'*5)*9
exec("print s[:60];"*4+"s=s[5:];")*6

a='/'*5;b='\\'*5
for i in range(24):print[a+b,b+a][i/4%2]*6

05AB1E, 15 bytes
„/\5×{R6×6FR4F=

Try it online!
Explanation:
„/\             # Push "/\"
   5×           # Repeat string five times: "/\/\/\/\/\"
     {          # Sort: "/////\\\\\"
      R         # Reverse: "\\\\\/////
       6×       # Repeat string six times
         6F     # Repeat the following six times:
           R    #   Reverse
            4F  #   Repeat the following four times:
              = #     Print without popping

Uses the CP-1252 encoding.

Bubblegum, 30 bytes
00000000: d307 8118 1020 9dc5 3544 3523 f8a4 b386  ..... ..5D5#....
00000010: aae6 e113 cfa3 f13c 1acf a3f1 0c00       .......<......

Obligatory Bubblegum answer.

Oh my goodness this language is awesome!

JavaScript (ES6), 68 60 58 bytes
A recursive function. Several optimizations inspired from chocochaos answer.
f=(n=1440)=>n--?'/\\'[n/240&1^n/5&1]+(n%60?'':`
`)+f(n):''

Demo

f=(n=1440)=>n--?'/\\'[n/240&1^n/5&1]+(n%60?'':`
`)+f(n):''

console.log(f());

I think you can leave out the first &1 and save two bytes

@HenrikChristensen That would only work for n < 480. For n >= 480, we'd need parentheses: (n/240^n/5)&1.

Brainfuck, 140 bytes
>>>++++++++[>++++++>++++++++++++<<-]++++++++++>->----<<<<<+++[>++++[>++++++[>>.....>.....<<<-]>.<<-]++++[>++++++[>>>.....<.....<<-]>.<<-]<-]

:-D

Oh, look! The brainfuck solution is eight bytes shorter than the Java solution. Time for Java coders to switch to brainfuck...

Java strikes back

Haskell, 77 70 57 bytes
a%b=(<*[1..a]).([1..b]>>)
unlines$4%3$5%6<$>["/\\","\\/"]

Boring concats and replicates instead of playing with sines. Old was:
unlines[["\\/"!!(ceiling$sin(pi*x/5)*sin(pi*y/4))|x<-[0.5..59]]|y<-[0.5..23]]

Brainfuck, 179 bytes
->++++++++[-<++++++>]++>+++++++++[-<++++++++++>]++++++++++>>>>+++[-<++++[-<++++++[-<+++++[-<<<.>>>]+++++[-<<.>>]>]<<.>>>]++++[-<++++++[-<+++++[-<<.>>]+++++[-<<<.>>>]>]<<.>>>]>]

I know this isn't the best score in the thread but I wanted to try out brainfuck and give this a try.
Edit:
I must've made an error while copypasting. This version should work

Welcome to the site!

Does not work for me. Browser hang up with this interpreter, and personnal one show a non expected 5 line output: /////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\  four times, then infinite \ .

Yes, it works :)

Python 2, 86 80 76 74 73 bytes
for z in range(24):a=('/'*5+'\\'*5)*24;print((a+a[::-1])*3)[z*60:z*60+60]

Could probably golf a few more off it but it's a start.
Edit
Saved 6 by removing some unneeded brackets
Another 4 by using a single string and then reversing it
Thanks @Adnan. Had a late night last night and still not fully awake yet :p
-1 by moving the *24 to the variable instead of using it twice

I believe that *6*4 is the same as *24? :p

Brainfuck, 149 bytes
++++++++++>++++++[>++++++++<-]>->+++++++++[>++++++++++<-]>++>+++[<<++++[<<++++++[>.....>>.....<<<-]<.>>>-]++++[<<++++++[>>>.....<<.....<-]<.>>>-]>>-]

The best interpreter EVAR!
This uses 6 cells (no wrapping, no modulo). Here they are:
0A 00 2F 00 5C 00

The 00 cells are used for the loop counters. Here, the counters are filled in with initial values:
0A 06 2F 04 5C 03

The leftmost counter is for the innermost loop (yes, I use nested loops of depth 3). Please note that the 4th cell (04 counter) is used twice, once for /////\\\\\..., and once for \\\\\/////... every time.
0A, 2F and 5C are the characters \n, / and \, respectively.

Pyke, 16 bytes
"/\"6*5m*n+4*sD3

After update today that allowed " in string literals, 17 bytes
"/\\"6*5m*n+4*sD3

Try it here!

Python 2.7 66 -> 56 -> 55 bytes
a="/"*5+"\\"*5;b=a[::-1];c=6*a+"\n";d=6*b+"\n";e=4*c+4*d;print e*3

new to code golfing
a="/"*5+"\\"*5;print(4*(6*a+"\n")+4*(6*a[::-1]+"\n"))*3

Thanks Stewie Griffin
Forgot a silly whitespace ;)

Welcome to PPCG! Nice first answer :) Can you skip some of the intermediate variables? At least d and e, maybe more. I haven't tested this, but it should be close: print(4*c+4*(6*b+"\n"))*3. It's 5 bytes less.

55 bytes: a="/"*5+"\\"*5;print(4*(6*a+"\n")+4*(6*a[::-1]+"\n"))*3

Canvas, 10 9 bytes
/５４＊╬６×３＊

Try it here!
Explanation:
/          push "/"
 54*       extend horizontally 5 times and vertically 4 times
    ╬      quad-palindromize with 0 overlap
     6×    repeat horizontally 6 times
       3*  and again vertically, 3 times

Pyth, 22 bytes
V6V4V12p*5?%+bN2\\\/)k

Try it here.
Explanation:
V6                     Loop 6 times, with N from 0 to 5:
  V4                   Loop 4 times, with H from 0 to 3:
    V12                Loop 12 times, with b from 0 to 11:
      p                Print without newline
        *              The repetition
          5            5 times of
          ?            if
            %          the remainder
              + b N    when the sum of b and N
              2        is divided by 2
          \\           then the "\" character
          \/           else the "/" character
    )                  End
                       (implicitly print with newline)
  k                    k (empty string)
                       (implicit end)
                       (implicit end)

Sorry if the explanation is a little hard to understand, but it was kinda complicated.

Dyalog APL, 24 bytes
(60⍴5/0 4)⊖60/⍪∊3⍴⊂4/'/\'

'/\'[4⌿5/2|+/¨⍳6 12] (requires ⎕io←0)

@ngn Why don't you just post it?

done

Ruby, 46 bytes
Creates the following string (70 characters, one set more than needed) then alternates between sampling characters 0..59 and 5..64from it.
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\

code and output
24.times{|i|puts ((?/*5+?\\*5)*7)[i/4%2*5,60]}

/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////

interesting mistake (a 7 instead of a 5)
24.times{|i|puts ((?/*5+?\\*5)*7)[i/4%2*7,60]}

/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\

C, 66 61 bytes
5 bytes saved thanks to orlp.
Straightforward character by character printing. 61 characters per row, last is newline (ASCII 10) and the others alternate between /47 and \ 92.
i;f(){for(i=1463;i;)putchar(i--%61?i%61/5+i/244&1?92:47:10);}

//call like this
main(){f();}

61 bytes: i;f(){for(i=1463;i;)putchar(i--%61?i%61/5+i/244&1?92:47:10);}.

@orlp thanks, I knew there had to be a better way with the i-- but I didn´t have time to look for it.

MATL, 18 16 bytes
'\/'6:&+thK5&Y")

Try it online!
Explanation
'\/'   % Push this string
6:     % Push array [1 2 3 4 5 6]
&+     % 6×6 matrix with all pair-wise additions from that array
th     % Concatenate horizontally with itself. Gives a 6×12 matrix
K      % Push 4
5      % Push 5
&Y"    % Repeat each entry of the matrix 4 times vertically and 5 times horizontally
       % This gives a 24×60 matrix
)      % Index (modularly) into the string. This produces the desired 24×60 char array

V,  22  21 bytes
Edit One byte won, thanks @DjMcMayhem:
5á\5á/05ä$4Ä5x$p4Ä3ä}

Changes are:

Y4P -> 4Ä Use V duplicate line instead of Vim built-in command (this will add a blank line at the end of the paragraph)
3äG -> 3ä} Duplicate the paragraph instead of the whole buffer (to avoid blank line generated by previous change)

Original post
5á\5á/05ä$Y4P5x$p4Ä3äG

Try it online
Decomposed like this:
5á\                    Write 5 \
   5á/                 Write 5 / after
      0                Go to the beginning of the line
       5ä$             Copy the text to the end of the line and repeat it 5 times
          Y4P          Copy the line and create 4 new copies
             5x$p      Delete the 5 first characters and put them at the end of the line
                 4Ä    Duplicate this line
                   3äG Duplicate the whole text

It's cool to see someone else using V! Up until recently, it's only been me. If you ever need help with it, feel free to ping me in the nineteenth byte

@DrMcMoylex Yup your language seems fun to use :-) I had a problem on this one: initially I wanted to use 5á\5á/05ä$5Ä5x$p4Ä3äG i.e. replace Y4P by 4Ä but for a reason that I don't understand it copies an additional blank line... If you can enlighten me on this one it would be nice. Also if I find some free time i'd gladly contribute to the language (especially issue #4)

Ah, yes that has troubled me many times. It's a known issue. The problem is that Ä is a synonym for dd, not Y. This is usually not an issue, but it causes some problems if the buffer has only one line or if you're on the last line.

Actually, I just realized, that approach would still work if you replaced 3äG with 3ä} since it won't yank that last newline. http://v.tryitonline.net/#code=NcOhXDXDoS8wNcOkJDXDhDV4JHA0w4Qzw6R9&input=

Ok I think I get why it didn't work now. And nice way to win 1 byte, thanks!

Actually, 21 bytes
"/\"5*SR6*;4α@R4α+3αi

Try it online!
-1 byte from Adnan
Explanation:
"/\"5*SR6*;4α@R4α+3αi
"/\"5*                 "/\" repeated 5 times
      SR               sort and reverse (result: "\\\\\/////")
        6*             repeat string 6 times (forms one row)
          ;4α          copy and push a list containing 4 copies
             @R4α+     push a list containing 4 copies of the reversed string, append to previous list (now we have one row of diamonds)
                  3α   repeat pattern vertically 2 more times
                    i  flatten and implicitly print

Can you do something like "/\"5*S for creating the string of slashes?

@Adnan Great idea!

Jelly, 17 16 bytes
⁾/\ẋ6Wẋ4;U$ẋ3x5Y

Try it online!
Thanks to 6710 (miles) for -1 byte.

I think you can save a byte with ⁾/\ẋ6Wẋ4;U$ẋ3x5Y

@miles Thanks, it seems I can't effectively use quicks yet :) And I knew I didn't need two Ys!

J, 31 28 19 bytes
4#_60]`|.\5#72$'/\'

Usage
   4#_60]`|.\5#72$'/\'
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////

APL, 30 bytes
A←240⍴'/////\\\\\'⋄24 60⍴A,⊖A

I'm quite new to APL, (I'm using APLX, but this should work across most implementations of APL), so this is a quite simplistic solution.
Explanation:
A ← 240 ⍴ '/////\\\\\' ⍝ set A to be a 240 character vector populated with '/////\\\\\'
⋄                      ⍝ statement separator
24 60 ⍴ A,⊖A           ⍝ populate a 24 by 60 character matrix with the concatenation
                          of A and the reverse of A (⊖A)

Brainfuck, 168 bytes
++++++[>++++++++<-]>-<+++++++++[>>++++++++++<<-]>>++<<+++++[>>>++<<<-]>>>>+++[>++++[>++++++[<<<<<.....>.....>>>>-]<<<.>>-]++++[>++++++[<<<<.....<.....>>>>>-]<<<.>>-]<-]

Java 7, 120 bytes
String c(){String r="";for(int i=0;i<1440;r+=(i%60<1?"\n":"")+(i/60%8<4?i%10<5?"/":"\\":i%10<5?"\\":"/"),i++);return r;}

Pushed everything into one loop. Beats Brainfuck, mission accomplished.
See it online: https://ideone.com/pZjma3

Python 2, 63 bytes
a='\n'.join([('/'*5+'\\'*5)*6]*4);print'\n'.join([a,a[::-1]]*3)

For Python 3, do this (65 bytes):
a='\n'.join([('/'*5+'\\'*5)*6]*4);print('\n'.join([a,a[::-1]]*3))

This uses the same method as my Jelly answer.

More efficient method than mine to start with

@ElPedro Basically, I just did some string/array manipulation. The trick is that I have prepared a bigger string: /////\\\\\/////... four times, separated by newlines

Octave, 50 48 bytes
Anonymous function:
@()repmat([A=repmat(47,4,5) B=A*2-2;B A ''],3,6)

You can try online here. Simply run the above command and then run the function with ans().
Essentially this creates an array of the value 47 which is 4 high and 5 wide. It then creates a second array of value 92 which is the same size.
The two arrays are concatenated into a checkerboard of [A B;B A]. The '' is concatenated as well to force conversion to character strings.
Finally the whole array is replicated 3 times down and 6 times across to form the final size.

Saved 2 bytes, thanks @StewieGriffin

no need for an anonymous function; save 3 bytes.

@TasosPapastylianou there is, otherwise it will print ans= before the pillow. Having it in the function gets around this as it is expected to return the answer to a variable rather than displaying it.

That's just semantics. I mean, if you're going to be pedantic I'd worry more about the 3-line warning messages that appear instead :p  Also the usual rules state that it needs to be either an output from a direct terminal command, or a callable function handle. Meaning you should assign your anonymous function to a handle (or add another 5 bytes to account for having to pring ans()). Which is pointless, since ans() still prints ans when run!

@TasosPapastylianou ans() is a callable function handle, so you don't need to assign it to something with, e.g. a=@..., because it is implicitly assigned to ans as a handle. Also it doesn't print ans= when run unless you specifically ask it to by not doing anything with the returned value and not adding a ;. If you did disp(ans()) it would only print the exact output (no ans=). But yes, the warning is annoying, however that didn't happen previously, so it isn't language specific, but rather interpreter specific.

Ok, we'll agree to disagree. The way I see it, if you're relying on disp(ans()) before getting your output, then you need to add 12 bytes to your answer. My own opinion is that this is just the way octave presents its result and that's fine.

Self-modifying Brainfuck, 91 bytes
>>+++[<++++[<++++++[<.....<.....>>-]<<<.>>>>-]++++[<++++++[<<.....>.....>-]<<<.>>>>-]>-]
\/

Try it online!
Same as my brainfuck answer, but uses the 3 last characters of the source code instead of generating them at runtime.

PHP, 73 69 bytes
for($s='/\\';$i<1440;$i++)echo$i%60<1?'
':'',$s[($i/5+($i/240|0))%2];

Demo
http://ideone.com/z7N1Md

69 bytes: for($s='/\\';$i<1440;$i++)echo$i%60<1?'\n':'',$s[($i/5+($i/240|0))%2]; (replace the \n with a real newline). echo isn't a function, so, it doesn't need parenthesys. Also, echo can receive multiple  values, separated by a comma. This really removes the need for those parenthesys. And then, inside your $s[...], the outer-most calculation doesn't need parenthesys either, since it is contained withing []. Using $s[($i/5+($i/240|0))%2] has the same effect and is shorter.

Thank you, updated! I didn't even know about echo accepting multiple parameters ^_^

echo and print accept multiple parameters. But print requires parenthesys with multiple parameters when used on a loop's increment, condition or assignment.

Can shave off that <1, by switching the expressions, echo$i%60?'':' ',, new line as expression 3 in the ternary.

PHP, 142 124 bytes
<?=str_replace(['#','-'],['/////','\\\\\\\\\\'],wordwrap(str_repeat(str_repeat("#-",24).str_repeat("-#",24), 4),12,"\n",1));

Previous version:
<?for($i=1;$i<4;$i++)echo wordwrap(str_repeat("/////\\\\\\\\\\",24),60,"\n",1)."\n".wordwrap(str_repeat("\\\\\\\\\\/////",24),60,"\n",1)."\n";

Output:
C:\PHP\>php this-is-my-pillow.php
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////

Vim,  44  27 bytes
EDIT Lot of bytes won thanks to @DrMcMoylex:
5i\<esc>5a/<esc>0y$5PY4P5x$pY3PyGPP

Original answer:
I'm not sure that really fits the rules of this site but I thought that was fun to try it:
i\<esc>59.:s;\v(.{5})\1;\1/////;g<CR>Y4P5x$pY3PyGPP

Which can be decomposed like this:
i\<esc>                       Insert a \
59.                           Repeat 59 time the insertion
:s;\v(.{5})\1;\1/////;g<CR>   Match 5 characters followed by the same 5 characters
                              And replace them by these 5 characters followed by 5 /
Y4P                           Copy the line and repeat it 4 times
5x$p                          On the current line delete 5 characters and put them
                              at the end of the line
Y3P                           Copy the line and repeat it 3 times
yG                            Copy all the lines
PP                            Repeat them 2 times

Oh hey statox, welcome to the site! This totally fits the rules. I golf mostly in vim. Just so you know, you could do 5i/<esc>5a\<esc>0y$5P at the start to save 9 bytes.

Hey DrMcMoylex (new name? :-) ) glad to see you here and that my answer fits. Also thanks for your hint, I'll edit my answer

Haha, yeah I temporarily changed my name because of this challenge, lol. I'll change it back in 30 days

APL, 16
4⌿5/1↓⍉12 7⍴'\/'

Try it on tryapl.org

SOML, 20 bytes
 /5* \5*+6*6{4{t}5{«

Explanation:
 /                    push "/", stack: ["/"]
  5*                  repeat it 5 times ["/////"]
     \                push "\" ["/////","\"]
      5*              repeat it 5 times ["/////","\\\\\"]
        +             add together ["/////\\\\\"]
         6*           repeat the string 6 times (it gets long here)
           6{         6 times repeat following code
             4{t}     output 4 times
                 5{«  put the 1st 5 chars at the end of the string

CJam, 24 23 bytes
"/\\"5e*6*]4*N*_W%]3*N*

ONLINE
Thanks 8478 (Martin Ender) for -1.
Explanation:
"/\\"5e*6*]4*N*_W%]3*N* Code
"/\\"                   Push "/\\"
     5                  Push 5
      e*                Repeat each
        6               Push 6
         *              Repeat
          ]             Wrap stack from [ to ToS in array
           4            Push 4
            *           Repeat
             N          Push N = "\n"
              *         Join
               _        Duplicate
                W       Push W = -1
                 %      Take every nth item
                  ]     Wrap stack from [ to ToS in array
                   3    Push 3
                    *   Repeat
                     N  Push N = "\n"
                      * Join

Vitsy, 28 26 bytes
This can be golfed a bit.
'\/'6\[4\[c\[4\[DO]r]aO]r]

Try it online!

Perl, 51 50 bytes
Perl 5.10.0+:
perl -E 'say+((@_=("/"x5,"\\"x5)x6,$/)x4,(pop@_,@_,$/)x4)x3'

Perl before 5.10.0 (52 bytes):
perl -e 'print+((@_=("/"x5,"\\"x5)x6,$/)x4,(pop@_,@_,$/)x4)x3'

Ungolfed:
say(
    (
        (
            @_ = ('/' x 5, '\\' x 5) x 6,
            $/,  # new line symbol
        ) x 4,
        (
            pop(@_),
            @_,
            $/,
        ) x 4,
    ) x 3
);

Thanx to @DomHastings for 1 byte.

Didn't think to use an array to store the slashes, nice! You can save 1 byte dropping the outermost () and prepend +: perl -E 'say+((@_=('/'x5,'\\'x5)x6,$/)x4,(pop@_,@_,$/)x4)x3'

Pyth, 24 bytes
Jj*4[*6+*5\/*5\\;j*3[J_J

Try it!
Explanation:
Jj*4[*6+*5\/*5\\;j*3[J_J
   4                     4
      6                  6
         5               5
          \/             "/"
        *                Repeat
             5           5
              \\         "\\"
            *            Repeat
       +                 Concatenate
     *                   Repeat
    [                    List
  *                      Repeat
 j                       Join
J                        Assign copy to J
                ;        Close argument list
                   3     3
                     J   J
                       J J
                      _  Reverse
                    [    List
                  *      Repeat
                 j       Join

That explanation was painful to write... wish there was some way to use <something>5"/\\" instead of +*5\/*5\\.

sC*5]"/\\" There is, but it's a byte longer.

I see I still have a fair bit to learn. I've only posted 2 Pyth answers but I hope I'm getting there. Any suggestions/comments as to how I could improve how I did it? Gratefully received if so :)

MATLAB, 58 44 bytes
Thanks to @Stewie Griffin for saving a bunch of bytes ;)
[repmat(kron(['/\';'\/'],ones(4,5)),3,6),'']

Old version:
p=@()char(47+45*kron(ones(3,6),kron([0 1;1 0],ones(4,5))))

PowerShell v2+, 44 bytes
,(,('/////\\\\\'*6)*4+,('\\\\\/////'*6)*4)*3

Abuses the crap outta the default Write-Output behavior to put a newline between elements.
Explanation
I'm also trying out a new explanation format, rather than the long prose I traditionally write.
,(,('/////\\\\\'*6)*4+,('\\\\\/////'*6)*4)*3
    '/////\\\\\'*6                            # Repeat this string 6 times
  ,(              )*4                         # Repeat it into an array of four elements
                     +                        # Array concatenate with
                      ,('\\\\\/////'*6)*4)    # The same with the slashes the other way
,(                                       )*3  # Repeat it into an array of three elements
                                              # (i.e., 24 total strings)

Befunge-98, 76 bytes
'/\::2%0`!\4c*/2%0`!-> #0 #\ #\' $ #\_\3k:4k,1+:c%0`!> #0 #, #a_:cad+*\`!#@_

TryItOnline!
String processing/generation can be difficult with only a stack available...
A couple bytes may be able to be shaved off here or there, but I beat brainfuck, so I'm happy.
Explanation
Push '/' on the stack
Swap top two (at the beginning, zero will now be on top). Call top = iterator = n
Calculate (n % 2 == 0) != ((n / 48) % 2 == 0)
If true, swap top two, replace '/' with '\', swap again
Swap top two (so that we now have the character to print on top, followed by n)
Duplicate the char 4 times, and print 5 times
Increment n
If n % 12 == 0, print a newline character
If !(288 > n), end, else repeat

Pyth, 49 48 40 37 34 bytes
J60K*24+*5\/*5\\V24:*3+K_K*JN+J*JN

OK, I'm just learning Pyth so this is a direct port of my Python answer. Still a lot of golfing to do but it works so I am posting it anyway. Any hints gratefully received :)
1 byte saved with thanks to @Flp.Tkc
-8 by working out how to do it with a variable
-3 by moving the *24 to the assignment of K
-3 by getting rid of the quotes

I've never tried pyth apart from looking at the docs once or twice, but I think you can replace FN24 with V24

Nice. Just tested and it works. Will check the docs on that.

C#, 126 Bytes
var s="";var c="/";for(int a=0;a<24;){for(int b=0;b<60;)s+=b++%5>0?c:c=="/"?c=@"\":c="/";s+="\n";c=a++%3>1?c=="/"?@"\":"/":c;}

string s is output.
It could be 3 byte less, when it is infinite.
Ungolfed
        var s = "";
        var c = "/";
        for (int a = 0; a < 24;)
        {
            for (int b = 0; b < 60;)//write line
            {
                s += b++ % 5 > 0 ? c : c == "/" ? c = @"\" : c = "/";//Change  /to \ and vice versa after five times
            }
            s += "\n";

            c = a++ % 3 > 1 ? c == "/"? c = @"\" : c = "/" :c; //Change  /to \ and vice versa after three lines
        }

Can save at least two bytes with b%5>0 and c=a%3>1... I'm not sure because I'm on my phone but you may be able to store c as a char instead of a string and save a few bytes using implicit int to char conversions. Also do you really need all the c= in the last line ? I think it can be c=a%3>1?c=="/"?"\\":"/“:c; I see why you do it in the inner loop due to assigning to c and appending to s at the same time but you can probably refactor that a bit for byte savings as well

Maybe also take the post increments out of the loop and add them into into the assignments... Ie s+=b++%5... and c=a++%3... save another two bytes

Thank you, I complete forgot these c= in last line. Implicit int to char conversions does not work, because char is 16bit and written number is 32bit int, so there is only cast avaiable.

GameMaker Language, 104 bytes
You should make sure that uninitialized variables don't throw an error. This setting is in the main page of Preferences. Otherwise, add e='' to the beginning of the program.
a="/////"b="\\\\\"d=b+a+b+a+b+a+b c=a+d d+=a for(i=0;i<24;i++)if i mod 8>3e+=d else e+=c e+="#" return e

P.S. Yes, each part of the for loop needs an expression. So I can't for(i=0;i<24;) and have i++ later.
Output
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////

Are there missing newlines?

C++ 138
void P(){int i,j,k,l;for(i=0;i<3;i++)for(j=0;j<8;j++)for(k=0;k<12;k++)for(l=0;l<5;l++)cout<<((j/4)?(k%2)?'/':'\\':(k%2)?'\\':'/')<<'\n';}

Ungolfed
#include<conio.h>
#include<iostream>
using namespace std;

void P()
{
    int i,j,k,l;
    for(i=0;i<3;i++)
        for(j=0;j<8;j++)
            for(k=0;k<12;k++)
                for(l=0;l<5;l++)
                    cout<<((j/4)?(k%2)?'/':'\\':(k%2)?'\\':'/')<<'\n';
}

int main()
{
    P();
    _getch();
    return 0;
}

Why braces on the second for loop?

edited @pinkfloydx33

Julia, 56 bytes
a="////\\\\\\\\"^6*"\n";print((a^4*a[[48:-1:1,49]]^4)^3)

Lithp, 166 characters
Line split for readability.
#::((def x #S,N::(invoke S repeat N))(var A (x "/" 5))(var B (x "\\" 5))
(var C (+ (x (+ A B) 6) (nl)))(var D (+ (x (+ B A) 6) (nl)))
(print (x (+ (x C 4) (x D 4)) 5)))

Sample usage:
% pillow.lithp
(
    (def f #::((def x #S,N::(invoke S repeat N))(var A (x "/" 5))(var B (x "\\" 5))(var C (+ (x (+ A B) 6) (nl)))(var D (+ (x (+ B A) 6) (nl)))(print (x (+ (x C 4) (x D 4)) 5))))
    (f)
)

Run with:
./run.js pillow.lithp

This is a fairly simple solution that repeats characters. There is no standalone repeat function yet, so invoke is used to call "string".repeat(N) and adds a bit to the count.

GolfSharp, 59 bytes
r(0,1440).s(n=>n%10<5^n%480<240?"\\":"/").j().S(60).j("\n")

Ruby, 83 + 14 = 97 bytes
puts Zlib.inflate Base64.decode64"eNrTB4EYECCdxTVENSP4pLOGqubhE8+j8Twaz6PxDAA3Pofw"

Add 14 bytes for -rzlib and -rbase64 flags.

R, 72 bytes
write(matrix(c(x<-rep(rep(c('/','\\'),e=5),24),rev(x)),24,60),'',60,,'')

builds a matrix of appropriate characters and writes it to stdout.
Try it online!

T-SQL, 113 bytes
DECLARE @ INT=0L:IF @%8<4PRINT REPLICATE('/////\\\\\',6)ELSE PRINT REPLICATE('\\\\\/////',6)SET @+=1IF @<24GOTO L

Formatted:
DECLARE @ INT=0
L:
   IF @%8<4 PRINT REPLICATE('/////\\\\\',6)
   ELSE PRINT REPLICATE('\\\\\/////',6)
   SET @+=1
IF @<24 GOTO L

Using both string literals seems to be the shortest option, trying to REPLICATE(REPLICATE('/',5)+REPLICATE('\',5) is way longer, as is using additional variables.

SOGL V0.12, 11 bytes
└5*5∙╬¡6*3∙

Try it Here!
Explanation:
└            push "/"
 5*          repeat 5 times
   5∙        repeat vertically 5 times
     ╬¡      quad-palindromize with 0 overlap and mirroring characters
       6*    multiply 6 times horizontally
         3∙  multiply 3 times vertically

Jstx, 21 bytes
♣/►\:►/;1BO♠/♦/!41o16

Not the shortest solution but I wanted to try this interesting challenge.
Explanation
♣  # Push literal 5
/  # Enter an iteration block over the first stack value.
►\ # Push literal \
:  # Push the sum of the second and first stack values.
►/ # Push literal /
;  # Push the difference of the second and first stack values.
1  # End an iteration block.
B  # Push five copies of the first stack value.
O  # Collapse all stack values into a string, then Push that string.
♠  # Push literal 6
/  # Enter an iteration block over the first stack value.
♦  # Push literal 4
/  # Enter an iteration block over the first stack value.
!  # Push a copy of the first stack value.
4  # Print the first stack value, then a newline.
1  # End an iteration block.
o  # Push the first stack value with characters in reverse order.
1  # End an iteration block.
6  # Ends program execution.

Try it online!

Pip -n, 24 bytes
(RF('/X6.'\X6)X24)X3<>72

Quad reflect is a bit weird in pip, so this answer uses normal reflect.
The -n flag joins lists with newlines.
Try it online!

MAWP, 88 bytes
3[4[6[5[68W1A;1A]%4[68W2A2W;1A]%1A]%52W;1A]4[6[5[68W2A2W;1A]%4[68W1A;1A]%1A]%52W;1A]%1A]

Try it!
Raise the max executions to at least 15000 to test it :D Oh, and be ready to wait for quite some time for it to finish.
MAWP 2.0, 61 bytes
3[4[6["/////\\\\\":1-]`10;1-]`4[6["\\\\\/////":1-]`10;1-]`1-]

Try it!

x86-16 machine code, IBM PC DOS, 40 bytes
Binary:
00000000: b85c 2fb1 18b3 0cf6 c103 7502 86e0 ba05  .\/.......u.....
00000010: 00cd 294a 75fb 86e0 4b75 f350 b00d cd29  ..)Ju...Ku.P...)
00000020: b00a cd29 58e2 dec3                      ...)X...

Listing:
B8 2F5C         MOV  AX, '/\'       ; the two chars
B1 18           MOV  CL, 24         ; CX = row counter
            ROW:
B3 0C           MOV  BL, 12         ; BX = pattern counter
F6 C1 03        TEST CL, 3          ; have displayed 4 lines of same direction?
75 02           JNZ  DIR            ; if not, continue with same
86 E0           XCHG AH, AL         ; otherwise, swap the chars
            DIR:
BA 0005         MOV  DX, 5          ; DX = char counter
            PATT:
CD 29           INT  29H            ; write char to console
4A              DEC  DX             ; have displayed 5 of the same?
75 FB           JNZ  PATT           ; if not, keep writing
86 E0           XCHG AH, AL         ; otherwise, swap the chars
4B              DEC  BX             ; have displayed 12 patterns on a line?
75 F3           JNZ  DIR            ; if not, keep writing patterns
50              PUSH AX             ; otherwise, save the chars and write a newline
B0 0D           MOV  AL, 0DH        ; CR char
CD 29           INT  29H            ; write to console
B0 0A           MOV  AL, 0AH        ; LF char
CD 29           INT  29H            ; write to console
58              POP  AX             ; restore original chars
E2 DE           LOOP ROW            ; loop until written 24 lines written
C3              RET                 ; return to DOS

A standalone PC DOS executable COM program.  Output to console:

Nibbles, 13 bytes
^3`<^4`:;^6`<^5"/\\"\$

explanation
^3                     # replicate 3 times
  `<                   # sort
    ^4                 # replicate 4 times
      `:               # list of two lists (for getting newlines)
        ;              # let (save value to $)
         ^6            # replicate 6 times
           `<          # sort
             ^5        # replicate 5 times
               "/\\"   # the string /\
                    \$ # reverse the saved value

Note that that last $ can't be omitted because in the binary form the sort needs to place more data after its arg

Charcoal, 26 bytes
ＵＯ⁵¦⁴/‖Ｍ↓→‖Ｍ↓→‖Ｍ‖ＢＯ²⁰‖ＢＯ↓⁸

Try it online! Link is to verbose version of code.
Explanation:
ＵＯ⁵¦⁴/  - drawing a 5 by 4 rectangle filled with /
‖Ｍ↓→            - reflect and mirror the canvas to the down and right direction (note that for this pattern order doesn't matter)
‖Ｍ             - reflect mirror without a argument (default is to the right, n times)
‖ＢＯ²⁰         - reflect butterfly overlap which would reflect the same thing n times to the left by default
‖ＢＯ↓⁸        - 8 characters but this time with a given direction which is down

Optimizing: -9, Thanks to @Neil for the help on reflects.

Powershell, 77 bytes
I must say I thought this would be easier with PowerShell, but it's quite hard to create something more condense than this.
$a=@("/","\");"$(1..6|%{1..3|%{1..6|%{$a[$b]*5;$a[!$b]*5};"rn"}; $b=!$b})"
More readable:
$a=@("/","\")
"$(1..6|%{
    1..3|%{
     1..6|%{
     $a[$b]*5
     $a[!$b]*5
        }
     "`r`n"}
    $b=!$b})"

I'm using the index numbers of the array in order to decide whether I should put \ or / and between every loop I simply toggle the variable.

Welcome to PPCG! I get your logic, but it doesn't seem to work quite right. With the code as-is, you're going to get a bunch of Index operation failed; the array index evaluated to null. errors since $b is uninitialized on the first inner loop of 1..6. Additionally, this will join the strings you're creating with spaces, since that's the default $OutputFieldSeparator when stringifying an array (what you're doing here).

Additionally, you don't need both r and n -- just n will work for newlines. You've also got an extra space between ; and $b=.

Must be ISE messing with me again. The host retains variables between each run, that's what got me here. Dammit.

You can fix the array index by putting a + in front -- like $a[+$b] -- to force a cast to int. However, that doesn't eliminate the spaces between elements. :-/

Batch, 132 bytes
@set s=/////\\\\\
@set s=%s%%s%%s%%s%%s%%s%
@set s=%s% %s:~5%/////
@for %%s in (%s% %s% %s%)do @for /l %%i in (1,1,4)do @echo %%s

Works by building up the two types of row, then looping through six rows four times per row.

Swift 3, 100 99 97 bytes
var a="/////",b="\\\\\\\\\\",c=""
(1...144).map{c+=a+b+($0%6<1 ?"\n":"")
$0%24<1 ?swap(&a,&b):()}

Could save 1 byte if Swift print function did not add a newline by default.
Edit 1:
Saved 1 byte by changing the if to ternary
if(i%24<1){swap(&a,&b)} -> i%24<1 ?swap(&a,&b):()
Edit 2:
Changed from for to map over the CountableClosedRange

Racket 156 bytes
(define g #t)(for((k 24))(for((i 12))(for((j 5))(display(if g "/""\\")))(set! g(if g #f #t)))
(when(= 0(modulo(add1 k)4))(set! g(if g #f #t)))(displayln""))

Ungolfed:
(define(f)
  (define g #t)
  (for ((k 24))
    (for ((i 12))
      (for ((j 5))
        (display (if g "/" "\\")))
      (set! g (if g #f #t)))
    (when (= 0 (modulo (add1 k) 4))
      (set! g (if g #f #t)))
    (displayln "")))

Testing:
(f)

Output:
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////

Java 7, 148 bytes
String c(){String r,z,y=z=r="",p="/////\\\\\\\\\\",q="\\\\\\\\\\/////";int i=0;for(;i++<6;y+=p,z+=q);for(i=0;i<24;r+=(i++%8<4?y:z)+"\n");}return r;}

Ungolfed & test code:
Try it here.
class M{
  static String c() {
    String r, z, y = z = r = "",
           p = "/////\\\\\\\\\\",
           q = "\\\\\\\\\\/////";
    int i = 0;
    for(; i++ < 6; y += p, z += q);
    for(i = 0; i < 24; r += (i++%8 < 4 ? y : z)+"\n");
    return r;
  }

  public static void main(String[] a){
    System.out.println(c());
  }
}

Output:
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////

PHP, 55 bytes
for(;$i<1440;)echo"/\\"[($i/5^$i/240)&1],"\n"[++$i%60];

toggles between forward and backward slash every 5 characters, inverted every 240 characters;
not counting newlines; newlines inserted every 60 characters.
has one trailing newline. Run with -r.

recursive program for 66 bytes:
<?="/\\"[($i/5^$i/240)&1]."\n"[++$i%60];if($i<1440)include"p.php";

save to file p.php; call from CLI (or insert ($i?"":"
"). after <?=)

Python 2, 83 55 bytes
x=('/'*5+'\\'*5)*6;print((x+'\n')*4+(x[::-1]+'\n')*4)*3

Try it online!
-28 bytes thanks to Leaky Nun

55 bytes: x=('/'*5+'\\'*5)*6;print((x+'\n')*4+(x[::-1]+'\n')*4)*3

TIO link please.

@CalculatorFeline Done

Python 3, 60 bytes
Lots of multiplying strings!
print((((('/'*5+'\\'*5)*6+'\n')*4)+(('\\'*5+'/'*5)*6+'\n')*4)*3)

Output
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////

tcl, 97
proc r s\ n {string repe $s $n}
puts [r [r [r /////[r \\ 5] 6]\n 4][r [r [r \\ 5]///// 6]\n 4] 3]

My try to outgolf myself didn't go well :( :
tcl, 102
proc r s\ n {string repe $s $n}
proc R s\ t {r [r [r $s 5][r $t 5] 6]\n 4}
puts [r [R / \\][R \\ /] 3]

runnable on: http://rextester.com/live/HURDH99224

Pyth, 21 20 bytes
J*6S*5"/\\"V6V4J)=_J

Try it online!
Python 3 translation:
J=6*sorted(5*"/\\")
for N in range(6):
    for N in range(4):
        print(J)
    J=J[::-1]

Excel (loaded with VBA), 70 62 bytes
Formula for each cell (A4 through BH27):
=IF(SIN(COLUMN()*0.62)*SIN(ROW()*0.8)>0,"\","/")

I'm not sure how to score this and I couldn't find a consensus. It's a 48 byte pure Excel formula, the same in every cell (but of course the fact that it should be in a particular range is also information). It takes 62 bytes to load it by executing this in the VBA Immediate window.
[A4:BH27]="=IF(SIN(COLUMN()*.62)*SIN(ROW()*.8)>0,""\"",""/"")"

Output

Saved 8 bytes by realizing I don't need .Formula in the VBA

Add++ -i, 27 bytes
L,"/\"5€*6*b]4*d€bR+3*bUBJn

Try it online!
The -i flag simply invokes the function with a clean stack and then outputs its return value.
How it works
L,		; Anonymous function
	"/\"	; Push this string			STACK = ["/\"]
	5€*	; Repeat each character 5 times		STACK = [["/////" "\\\\\"]]
	6*	; Repeat the array 6 times		STACK = [["/////" "\\\\\" "/////" "\\\\\" "/////" "\\\\\" "/////" "\\\\\" "/////" "\\\\\" "/////" "\\\\\"]]
	b]4*	; Repeat the whole thing 4 times	STACK = [[["/////" "\\\\\" ... "/////" "\\\\\"]]]
	d	; Duplicate				STACK = [[["/////" "\\\\\" ... "/////" "\\\\\"]] [["/////" "\\\\\" ... "/////" "\\\\\"]]]
	€bR	; Reverse the second copy		STACK = [[["/////" "\\\\\" ... "/////" "\\\\\"]] [["\\\\\" "/////" ... "\\\\\" "/////"]]]
	+	; Concatenate				STACK = [[["/////" "\\\\\" ...] ... [... "\\\\\" "/////"]]]
	3*	; Repeat 3 times			STACK = [[["/////" "\\\\\" ...] ... [... "\\\\\" "/////"]]]
	bUBJn	; Concatenate and grid			STACK = ["/////\\\\\...\\\\\/////"]

Vyxal, 16 bytes
‛/\5*s6(4(:6*,)Ṙ

Try it Online!
Do not worry, your pillow will be remembered.
‛/\              # String `/\`
   5*            # times 5
     s           # Sort
      6(         # Six times
        4(    )  # Four times
          :      # Duplicate
           6*    # 6 lots
             ,   # Output
               Ṙ # Reverse

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


text:
Primenary Strings

A Primenary (binary-prime) string is one which, when written as a binary grid, every row and column has a prime total.

That's quite a vague explanation, so let's break it down with a worked example...

For this example we'll use the string bunny:
First, find the ASCII code point of each character and its binary representation:
Char | ASCII | Binary

b      98      1100010
u      117     1110101
n      110     1101110
n      110     1101110
y      121     1111001

Take these binary values, from top to bottom, and arrange them into grid (adding leading zeros if necessary):
1 1 0 0 0 1 0
1 1 1 0 1 0 1
1 1 0 1 1 1 0
1 1 0 1 1 1 0
1 1 1 1 0 0 1

Then, count the number of 1s in each row and column:
1 1 0 0 0 1 0   > 3
1 1 1 0 1 0 1   > 5
1 1 0 1 1 1 0   > 5
1 1 0 1 1 1 0   > 5
1 1 1 1 0 0 1   > 5

v v v v v v v

5 5 2 3 3 3 2

If, and only if, every single total is prime (such as here) then the string is a valid binary-prime.

The Challenge
Your task is to create a function or program which, when given a string, returns/outputs truthy if the string is primenary, and falsy otherwise.
Rules/Details

You may assume that the string's characters will always be in the ASCII range 33-126 (inclusive).
The string will not be empty.
A primenary string does not have to have a prime length - for example, W1n* is valid, despite having 4 characters.
This is code-golf, so the shortest answer (in bytes) wins - but all submissions are welcome.
Standard loopholes are banned.

Test Cases
'husband'     -> True
'HOTJava'     -> True
'COmPaTIBILE' -> True
'AuT0HACk'    -> True

'PPCW'        -> False
'code-golf'   -> False
'C++'         -> False
'/kD'         -> False

'HI'          -> False
'A'           -> False

There is also a working, but incredibly verbose Python example on repl.it that you can test your solution against.

Can I ask how you discovered that husband was valid?  Or any of them?  Great problem, though!

@GabrielBenamy I'm glad someone asked! I looped through an online dictionary file, trying a few random capitalizations of each letter, sometimes switching letters for numbers, etc. Then I had a look through the outputted list and picked a couple of test cases I liked

Every 1-2 character input is guaranteed to return False, correct?

... because 0 and 1 are not prime, and every 1-2 char input string containing only chars in the given range is guaranteed to contain at least one 0 or 1 as a vertical sum. You should add some 1 and 2 character strings as test cases.

@mbomb007 1 char inputs cannot have prime numbers columnwise, so they will return false. 2 char inputs could, but not in the ASCII range we're using, so for this scenario you're correct.

All of the test cases only have prime characters, i.e. rows in the bitmatrix, so they don't cover the case where only columns are checked for primality.
Add beezz to fix this. There are two non-prime rows, but only prime columns in beezz.

What is the intended output for 7/8?

Of the answers I was able to test, six accept 7/8 and six reject 7/8.

The actual problem with 7/8 is leading zeroes. Should leading columns be ignored, if they are completely zeroed? Or should we always check 7 bits for each character? What about zero columns in the middle?

MATL, 10 bytes
BtXsw!shZp

Try it online!
This is the ideal language for the job. It's pretty much a literal transliteration of the challenge specification.
Bt % Converts input to binary matrix, duplicate
Xs  % Sum columns (alternative X version to prevent defaulting to sum along first non-singleton dimension, thanks @Jonathan Allan)
w! % Get the duplicate to the top of the stack, transpose
s  % Sum again
h  % Concatenate horizontally
Zp % Check primality element-wise. Display implicitly.

Since any zero makes a MATL array falsy as per meta, nothing else is needed  - basically, an implicit A is called on ? (if).

a should be falsy, but returns 1 1? (its columns do not add up to primes)

I think BtXsw!shZp would fix this and be a winner for 10.

@Flp.Tck Completely forgot about MATLAB's 'forgiving'  behaviour when working with row vectors. I'm sorry, fixed it now.

Works now :) (might want to update the try it online link tho)

@Flp.Tkc Done. Thanks for a nice challenge!

Jelly, 13 12 11 bytes
OBUZ;$S€ÆPẠ

TryItOnline! or all test cases
How?
OBUZ;$S€ÆPẠ - Main link: word                  e.g. ha!
O           - cast to ordinals                 e.g. [104,97,33]
 B          - convert to binary                e.g. [[1,1,0,1,0,0,0],[1,1,0,0,0,0,1],[1,0,0,0,0,1]]
  U         - reverse each entry (say "b")     e.g. [[0,0,0,1,0,1,1],[1,0,0,0,0,1,1],[1,0,0,0,0,1]]
     $      - last two links as a monad
   Z        - transpose                        e.g. [[0,1,1],[0,0,0],[0,0,0],[1,0,0],[0,0,0],[1,1,1],[1,1]]
    ;       - concatenate with "b"             e.g. [[0,1,1],[0,0,0],[0,0,0],[1,0,0],[0,0,0],[1,1,1],[1,1],[0,0,0,1,0,1,1],[1,0,0,0,0,1,1],[1,0,0,0,0,1]]
      S€    - sum €ach                         e.g. [2,0,0,1,0,3,2,3,3,2]
        ÆP  - is prime (1 if prime, 0 if not)  e.g. [1,0,0,0,0,1,1,1,1,1]
          Ạ - all truthy?                      e.g. 0

05AB1E, 17 bytes
Çžz+b€¦€SDøìO0ÛpP

Try it online!

Jelly, 15 bytes
O+⁹Bṫ€3µS€;SÆPP

Try it online! or Verify all test cases..
Explanation
O+⁹Bṫ€3µS€;SÆPP  Main link. Input: string z
O                Ordinal, get ASCII value of each char
  ⁹              Nilad representing 256
 +               Add 256 to each ordinal value
   B             Binary digits of each
    ṫ€3          Tail, take each list of digits from the 3rd value to the end
                 These are the last seven digits of each
       µ         Start a new monadic chain
        S€       Sum each list of digits by rows
           S     Sum by column
          ;      Concatenate
            ÆP   Test if each is prime, 1 if true else 0
              P  Product

Mathematica, 75 bytes
And@@Join@@PrimeQ@{+##&@@#,+##&@@@#}&@IntegerDigits[ToCharacterCode@#,2,7]&

Unnamed function taking a string as input and returning True or False.
ToCharacterCode@# converts the input into the list of its ASCII values; IntegerDigits[...,2,7] turns each value into the list of its bits, padded to length 7 if necessary. So now we have a 2D array and we want all its row sums and column sums; lo and behold, the character-spasm {+##&@@#,+##&@@@#}&@... does exactly that (it applies the +##&, "sum all arguments", function to the list of vectors in the first coordinate using @@, and to each vector as its own list of integers in the second coordinate using @@@). Then we just check whether the results are PrimeQ, flatten the list with Join@@, and take the And of all those values.

O5AB1E, 12 bytes
Çžy+bø€SOp¦W

Try it online!
This is my first code golf so go easy :)
Ç              % Converts the implicit input into ascii values
 žy+           % Adds 128 to each value, inspired by Emigna as a way to pad zeros
    b          % Convert all values into bits
     ø         % Transpose
      €SO      % Sum each string of binary digits created
         p¦    % Check if each element is prime and cut the first element out (adding 128 makes it equal to the number of characters)
           W   % Take the minimum value to effectively "and" all the elements

This yield an empty result for a single letter input. I'm not well versed in O5AB1E but if that is a falsey value, it's ok.

Ruby -rprime, 100 bytes
->s{a=s.bytes.map{|b|b.digits 2}
a.all?{|r|r.sum.prime?}&([0]*7).zip(*a).all?{|c|c.count(1).prime?}}

Try it online!
Explanation
->s{
    a=s.bytes                       # Get byte values from string
             .map{|b|b.digits 2}    # For each, map it to its binary digits
                                    #   (least significant digits first)
a.all?{|r|r.sum.prime?}             # Each character has a prime number of 1's?
    &                               # Bit-and (because it saves bytes here)
    ([0]*7).zip(*a)                 # Zip bit array with an all-zero array
                                    #   (If we don't, then uneven array lengths
                                    #   cause some columns to not be returned.)
    .all?{|c|c.count(1).prime?}     # All columns have a prime number of 1's?
                                    #   (We use count instead of sum here because
                                    #   zip pads columns with trailing nils, which
                                    #   can't be added to numbers via sum.)
}

Groovy, 151 137 bytes
{p={x->x<3||(2..(x**0.5)).every{x%it}};y={it.every{p(it.count("1"))}};x=it.collect{0.toString((int)it,2) as List};y(x)&&y(x.transpose())}

No primality check in groovy...
p={x->x<3||(2..(x**0.5)).every{x%it}}; - Closure for primality testing.
y={it.every{p(it.count("1"))}}; - Closure to ensure that all counts of "1" for a passed binary 2D array are prime.
x=it.collect{0.toString((int)it,2) as List}; - Coversion from string to binary array.
y(x)&&y(x.transpose()) - For all prime-validated sums in the main matrix and the transposed matrix, ensure that they return true.

Python 3, 228 227 225 bytes
Not a great answer, I wasn't able to golf it as much as I would've liked, but I spent so long on it I feel I should post it. Suggestions on cutting bytes would be greatly appreciated.
r=range
n=[format(ord(c),"08b")for c in input()]
n=map(lambda s:s.count("1"),n+["".join([f[1]for f in filter(lambda e:e[0]%8<1,enumerate("X"*-~i+"".join(n)))][1:])for i in r(8)])
print(all(all(s%d for d in r(2,s))for s in n))

Edit 1: replaced e[0]%8==0 with e[0]%8<1, losing a byte. Thanks Flp.Tkc!
Edit 2: replacing (i+1) with -~i, losing two additional bytes. Thanks Erik for exposing how bad my bit-level knowledge is :) While testing this revision, I discovered that kappa is valid... make of that what you will.

could you change e[0]%8==0 to e[0]%8<1?

@Flp.Tkc Good spot! There's no reason why that can't be done.

@Flp.Tkc I don't think I could save bytes by making it a function. I like how you've got 404 rep btw :)

It is supposed to be <1, not <0?

@Destructible Watermelon yep let me correct that.

Welcome to PPCG!

BTW, you can golf two by replacing (i+1) with -~i.

@EriktheGolfer wow... code-golf royalty on my submission! Thanks for the suggestion.

@FourOhFour You made a typo: "X"*-~1 should be "X"*-~i instead.

I don't think this works. 0 and 1 are not prime numbers.

Your program always returns True for strings 1 character long, but should always return False.

@mbomb007 yep, it's an issue with my primality checking code. I'll look into fixing it.

I just looked in the chat history and found your comment on how this is your favourite question type. You even sparked the creation of a new tag, decision-problem! I'll make sure to post more like this in the future :)

@Flp.Tkc yep, I love this stuff. This was a great challenge so I look forward to your next ones!

@FourOhFour Currently I'm working on this challenge, after that I'll see if I can get some more decision problems going ;)

@Flp.Tkc That's a neat challenge idea! I've got a few ideas for a second challenge myself but none are fully formulated.

Perl, 151 121 111 + 3 = 114 bytes
Run with -lF.  The program will only function correctly for the first input.  Terminate the program and rerun for your next input.
Thanks to @Dada for letting me know the // after F were redundant.  An additional byte can be removed (for 112) by piping the input in via echo -n, but I feel that that's technically adding more code, so YMMV.
for$c(@a=map{sprintf"%07b",ord}@F){$b[$_].=substr$c,$_,1 for 0..6}s/0//g,$d|=/^1?$|^(11+?)\1+$/ for@a,@b;say!$d

Readable:
                                     #Implicitly split input into characters in @F array
for$c(@a=map{sprintf"%07b",ord}@F)  #Convert @F to 7-bit binary as @a, then loop through it
    $b[$_].=substr$c,$_,1 for 0..6   #Transpose @a's bits into @b
}
s/0//g,$d|=/^1?$|^(11+?)\1+$/ for@a,@b; #Remove any zeros, then run through composite regex
say!$d                          #If all composite regex checks fail, then it's fully prime.

A version that only works on the first input is perfectly fine, so you can put the 141 bytes version as the main one, and suggest the other one to use on multiple inputs.

Also note that you can omit the // after -F, and you can take the input without final newline (with echo -n) to get rid of -l flag.

K (oK), 40 33 bytes
Solution:
&/{2=+/d=_d:x%!x}'+/'m,+m:(7#2)\'

Try it online!
Explanation:
Half is creating the matrix, the other half is the primality check.
&/{2=+/d=_d:x%!x}'+/'m,+m:(7#2)\' / the solution
                                ' / apply to each (')
                               \  / decode
                          (   )   / do this together
                           7#2    / 7#2 => 2 2 2 2 2 2 2
                        m:        / save as m
                       +          / transpose
                     m,           / append to m
                  +/'             / sum (+/) each (')
                 '                / apply to each
  {             }                 / lambda taking implicit x
              !x                  / range 0..x
            x%                    / x divided by ...
          d:                      / save as d
         _                        / floor
       d=                         / equal to d?
     +/                           / sum (+/)
   2=                             / equal to 2?
&/                                / minimum

Ruby -rprime, 95 78 bytes
->s{a=s.bytes.map{[*_1.digits(2),0][..6]}
(a+a.transpose).all?{_1.sum.prime?}}

Attempt This Online!
Explanation
Pretty simple. The first line gets the binary digits of each character as an array padded out to seven digits:
a = s.bytes.map { [*_1.digits(2), 0][..6] }

The second line sums the rows and columns and tests if they're all prime:
(a + a.transpose).all?{ _1.sum.prime? }

Python 3, 209 189 180 171 160 bytes
Thanx squid for -9 bytes :)
def p(s):n=s.count('1');return(n>1)*all(n%i for i in range(2,n))
def f(s):t=[f'{ord(c):07b}'for c in s];return all(map(p,t+[[u[j]for u in t]for j in range(7)]))

Try it online!

I like how you rewrote the test case print statement :)

Yeah I'm a smidge obsessive compulsive about f-strings... Also, isn't it equivalent if you remove t+ in the map statement?

Nope, because the prime check needs to cover both rows and columns in the bit matrix. t has all the rows, while [[t[i][j]..i..]..j..] is the transposed t, i.e. the columns. If  there is a shorter way to transpose the matrix, we can save more bytes :)

It's working when I try it, do you know of a string that breaks it?

Yes. beezz should return false, but does not. It's because the prime check is broken, it returns True for 4 bits. Try print(p('1111')). Fixed it now. All the test cases did not cover that, because all of the used characters ar primenary.

JavaScript (Node.js), 149 146 ... 134 130 129 bytes
x=>[...x].map(y=>a=[...a.map(n=>y.charCodeAt()&2**i++?++z&&-~n:n,z=i=0),z],a=[...Array(7)])&&!a.some(n=>(P=r=>n%--r?P(r):~-r)(n))

Try it online!
Explanation
x=>                        // Main function:
 [...x].map(               //  For each y in x:
  y=>
   a=[...a.map(            //   For each i in range(0, len(a)):
    n=>
     y.charCodeAt()&2**i++ //    If y AND 2**i is not zero:
     ?++z&&-~n:n,          //     z = z + 1; a[i] = a[i] + 1 (1 if a[i] is undefined)
    z=i=0                  //   Initially z = 0
   ),z],                   //   Then push z at the end of a
  a=[...Array(7)]          //  Initially a = [undefined] * 7
 )&&!a.some(               //  Then for each n in a:
  n=>(
   P=r=>                   //   Composite function:
    n%--r?                 //    If n % (r - 1) == 0 or r == 1:
     P(r)                  //     Return P(r - 1)
    :~-r                   //    Else: Return r - 2
  )(n)                     //   Starting from r = n
 )                         //  Return whether the composite function returns 0 for all n.

How does it even work!?

y.charCodeAt()&2**i

We need this code to return the corresponding bit of y.charCodeAt() if 0 <= i < 7, and 0 otherwise.
When i < 7, the code apparently works as usual.
When 7 <= i <= 32, since the corresponding bit of y.charCodeAt() is 0 anyway, the result is 0 as expected.
When 32 < i < 1024, since int32(2**i) == 0, the result is 0 as expected.
When 1024 <= i, we have 2**i == Infinity, and since int32(Infinity) == 0, the result is 0 as expected.

(P=r=>n%--r?P(r):~-r)(n)

For simplicity we let R = --r = r - 1.
This helper function terminates when n % R == 0 or n % R is NaN.

n % R == 0: R is a factor of n.

If R == 1, then n is prime because all 1 < R < n can't divide n. Return 0 (falsy).
If R == -1, then n == 0. Return -2 (truthy).
Otherwise, return R - 1 where R - 1 > 0 (truthy).

n % R is NaN: Invalid modular calculation.

If R == 0: n == 1. Return -1 (truthy).
If n is NaN: R is NaN. Return -1 (truthy).

As a result, only when R == 1 can this function return a falsy value, indicating n is prime.

128

Pyth, 37 bytes
L.AmP_sdb=sMM.[L\0lh.MlZQ=.BMQ&yZy.TZ

Try it online!

                                 Code | Explanation
--------------------------------------+----------------------------------------------------------------
L.AmP_sdb=sMM.[L\0lh.MlZQ=.BMQ&yZy.TZ | Full code
L                                     | Define function y(b):
   m    b                             |   For each d in b:
    P_sd                              |     Is the sum of the elements of the list prime?
 .A                                   |   Return whether all elements of the resulting list are truthy
                         =   Q        | Assign the following to Q:
                          .BMQ        |   The list of binary strings for each character in the input
         =             Z              | Assign the following to Z:
               L             Q        |   For every element in Q:
             .[ \0                    |     Pad with 0 on the left
                  lh.MlZQ             |     To the length of the longest element in Q
            M                         |   For each element in the resulting list:
          sM                          |     Convert each character to an integer
                              &yZ     | Print y(Z) AND
                                 y.TZ |   y( <Transpose of Z> )

Brachylog, 14 bytes
ạḃᵐB↔ᵐz₁,B+ᵐṗᵐ

Try it online!
Outputs through success or failure. (In the case of success, a list of all column and row sums is available through the output variable.
   B              The variable B is
ạ                 the codepoints of the input
 ḃᵐ               converted to lists of binary digits,
    ↔ᵐ            which with each list reversed
      z₁          then zipped without cycling
        ,B        and concatenated with B
          +ᵐ      has elements which all sum to
            ṗᵐ    prime numbers.

PHP, 173 bytes
for($r=1;$b=substr_count($t[$i]=sprintf('%07b',ord($argv[1][$i++])),1);)$r&=$b==2|$b%2&$b>2;for(;$k++<7;){for($b=$j=0;$t[++$j];$b+=$t[$j][$k-1]);$r&=$b==2|$b%2&$b>2;}echo$r;

Test it online

JavaScript, 234 bytes
f=z=>(z=[...z].map(v=>v.charCodeAt(0))).map(v=>v.toString(2).replace(/0/g,"").length).every((p=v=>{for(i=2;i<v;i++){if(v%i===0){return 0}};return v>1}))&&[...""+1e6].map((v,i)=>z.reduce((a,e)=>!!(e&Math.pow(2,i))+a,0)).every(v=>p(v))

We get the horizontal values by converting the number to binary, removing the zeros using a string replacement, and then counting the 1s.
The vertical sums are obtained by looping 1 to 7 and using a bitwise AND with 2 raised to the nth power.

Math.pow(2,i) can be shortened to (1<<i) assuming i<32, maybe saving 7 bytes, maybe not though.

Perl 5 -MList::Util=all,sum -pF, 96 92 bytes
$_=all{//;all{$'%$_}2..$_-1}(map{$_=sprintf'%07b',ord;y/1//}@F),map{sum map{s/.//;$&}@F}0..6

Try it online!

Clojure, 180 bytes
#(let[S(for[i %](for[j[1 2 4 8 16 32 64]](min(bit-and(int i)j)1)))A apply](not-any?(fn[i](or(= i 1)(seq(for[d(range 2 i):when(=(mod i d)0)]d))))(into(for[s S](A + s))(A map + S))))

There might be a shorter way of generating bit lists and also the primality test.

Python 3, 164 bytes
import numpy;a=numpy.array([list(f'{ord(_):07b}')for _ in input()]).astype(int);print(all([(v>1)*all(v%i for i in range(2,v))for v in set(a.sum(0))|set(a.sum(1))]))

Uiua SBCS, 23 bytes
=1⧻°/×+×4=0.⊂∩/+⟜⍉⋯-@\0

Try it!

05AB1E, 11 bytes
Ç2вíD0ζ«OpP

Try it online or verify all test cases.
2в and O could alternatively be b and 1ö in the legacy version of 05AB1E:
Try it online or verify all test cases.
Explanation:
Ç            # Convert the (implicit) input-string to a list of codepoint-integers
 2в          # Convert each integer to a binary-list
   D         # Duplicate the current list of lists
    í        # Reverse each inner list in the copy
      ζ      # Zip/transpose; swapping rows/columns,
     0       # using 0 as filler for unequal length rows
       «     # Merge the two lists of lists together
        O    # Sum each inner list
         p   # Check for each sum whether it's a prime
          P  # Check that all of them are truthy
             # (after which the result is output implicitly)

 b           # Convert each integer to a binary-string
        1ö   # Convert each binary-string to base-1,
             # which is a vectorized method of summing digits of integers within a list

source: Stack Exchange

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

sort: votes