[Question]
  [
Here is a simple challenge for you: You must produce this ASCII representation of a chess board. White is represented by uppercase characters, and black is represented by lowercase. Empty tiles are represented by a `.`. Here is the full board:
```
rnbqkbnr
pppppppp
........
........
........
........
PPPPPPPP
RNBQKBNR
```
Since this is a [kolmogorov-complexity](/questions/tagged/kolmogorov-complexity "show questions tagged 'kolmogorov-complexity'") question, you may not take any input and you must output this board by any default method, for example, saving a file, printing to STDOUT or returning from a function. You *may* optionally produce one trailing newline. Standard loopholes apply, and the shortest program in bytes!
However, remember this is equally as much a competition between submissions in the same language. While it's unlikely that a languages like Java could beat a language like perl, or a golfing language like pyth or cjam, having the shortest Java answer is still really impressive! To help you track the shortest answer in each language, you may use this leaderboard, which will show the shortest submission by language and overall.
## Leaderboards
To make sure that your answer shows up, please start your answer with a headline, using the following Markdown template:
```
# Language Name, N bytes
```
where `N` is the size of your submission. If you improve your score, you *can* keep old scores in the headline, by striking them through. For instance:
```
# Ruby, <s>104</s> <s>101</s> 96 bytes
```
If there you want to include multiple numbers in your header (e.g. because your score is the sum of two files or you want to list interpreter flag penalties separately), make sure that the actual score is the *last* number in the header:
```
# Perl, 43 + 2 (-p flag) = 45 bytes
```
You can also make the language name a link which will then show up in the leaderboard snippet:
```
# [><>](http://esolangs.org/wiki/Fish), 121 bytes
```
```
var QUESTION_ID=95745,OVERRIDE_USER=31716;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="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});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;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>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}
```
```
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>
```
  
[Answer]
# Vim, 26 bytes
`irnbqkbnr<Esc>Y6p5Vr.VrpYGPgUj`
Relies on a fresh Vim, or else `5V` may select the wrong area.
* `irnbqkbnr<Esc>`: Write the top row. Easy enough.
* `Y6p`: Make the rest of the rows, *except one*. Of course all but the top and bottom rows contain the wrong characters.
* `5Vr.`: When you haven't used visual mode yet in the session, you can do things like this to select 5 lines. If you typed the same thing again right away, it would try to select 25 lines. Vim is weird like that.
* `Vrp`: We're already on line 2, so let's make a pawn line.
* `YGP`: Copy that pawn line into its place at the bottom. This is why I used `6p` instead of `7p` before.
* `gUj`: Capitalize the white pieces.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~25~~ 24 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
‚Äú.‚Äú.‚Äúp‚Äúrnbqkbn‚Äù·πÅ‚Ç¨8¬µ·πö;≈íuY
```
[Try it online!](http://jelly.tryitonline.net/#code=4oCcLuKAnC7igJxw4oCccm5icWtibuKAneG5geKCrDjCteG5mjvFknVZ&input=)
*Thanks to @Lynn for golfing off 1 byte!*
### How it works
```
‚Äú.‚Äú.‚Äúp‚Äúrnbqkbn‚Äù·πÅ‚Ç¨8¬µ·πö;≈íuY  Main link. No arguments.
‚Äú.‚Äú.‚Äúp‚Äúrnbqkbn‚Äù           Yield [".", ".", "p", "rnbqkbnr"].
               ·πÅ‚Ç¨8        Mold-each 8; reshape each string like the array
                          [1, 2, 3, 4, 5, 6, 7, 8], i.e., cyclically repeat its
                          contents to create strings of length 8.
                          This yields the upper half of the board in reversed
                          order, i.e., the string array
                          A := "........", "........", "pppppppp", "rnbqkbnr"].
                  ¬µ       Begin a new, monadic chain. Argument: A
                   ·πö      Reverse A.
                     ≈íu   Convert all characters in A to uppercase.
                    ;     Concatenate the results to both sides.
                       Y  Join the strings, separating by linefeeds.
```
[Answer]
# [Brainfuck](https://esolangs.org/wiki/brainfuck), 224 bytes
```
+++++[>+++[>++++++<-]+<-]>>.[>>+>+<<<-]>>>[<<<+>>>-]<<<----.<+++[>---<-]>.>>-.------.<<.>>+++.++++.--<++++++++++>>++++++++++.<........>.[>+++++<-]>----<++++[>........<<<.>>-]<........<.>++.----.<<.>>+++.------.<<.>>+++.++++.
```
Took almost an hour to get this.
[Answer]
## Python 2, 63 bytes
```
print"\n".join(["rnbqkbnr","p"*8]+["."*8]*4+["P"*8,"RNBQKBNR"])
```
Unfortunately, the fairly simple approach was much shorter than the "clever" stuff I tried at first...
Bonus answer, also 63 bytes:
```
print"\n".join(["rnbqkbnr"]+[c*8for c in"p....P"]+["RNBQKBNR"])
```
[Answer]
# [05AB1E](http://github.com/Adriandmen/05AB1E), 24 bytes
Uses [CP-1252](http://www.cp1252.com/) encoding.
```
"rnbqkbnr"'p8√ó'.8√óD)√Çu¬´¬ª
```
[Try it online!](http://05ab1e.tryitonline.net/#code=InJuYnFrYm5yIidwOMOXJy44w5dEKcOCdcKrwrs&input=)
**Explanation**
```
"rnbqkbnr"                # push the string "rnbqkbnr"
                          # STACK: "rnbqkbnr"
          'p8√ó            # push the char "p" repeated 8 times
                          # STACK: "rnbqkbnr", "pppppppp"
              '.8√ó        # push the char "." repeated 8 times
                          # STACK: "rnbqkbnr", "pppppppp", "........"
                  D       # duplicate
                          # STACK: "rnbqkbnr", "pppppppp", "........", "........"
                   )      # wrap in list
                          # STACK: ["rnbqkbnr", "pppppppp", "........", "........"]
                    √Ç     # push a reversed copy of the list
                          # STACK: ["rnbqkbnr", "pppppppp", "........", "........"], 
                                   ["........", "........", "pppppppp", "rnbqkbnr"]
                     u¬´   # convert to upper-case and concatenate
                          # STACK: ['rnbqkbnr', 'pppppppp', '........', '........', 
                                    '........', '........', 'PPPPPPPP', 'RNBQKBNR']
                       ¬ª  # join list by newline
```
[Answer]
# [Actually](http://github.com/Mego/Seriously), 26 bytes
```
'p8*"rnbqkbnr"‚îÇ√ª@√ª4'.8*n((
```
[Try it online!](http://actually.tryitonline.net/#code=J3A4KiJybmJxa2JuciLilILDu0DDuzQnLjgqbigo&input=)
Explanation:
```
'p8*"rnbqkbnr"‚îÇ√ª@√ª4'.8*n((
'p8*                        "p"*8 ["pppppppp"]
    "rnbqkbnr"              that string ["rnbqkbnr", "pppppppp"]
              ‚îÇ             duplicate stack ["rnbqkbnr", "pppppppp", "rnbqkbnr", "pppppppp"]
                √ª@√ª         uppercase the dupes ["RNBQKBNR", "PPPPPPPP", "rnbqkbnr", "pppppppp"]
               4   '.8*n    "."*8, 4 times ["RNBQKBNR", "PPPPPPPP", "........", "........", "........", "........", "rnbqkbnr", "pppppppp"]
                        ((  move the uppercase strings to the bottom of the stack, implicitly print
```
[Answer]
## PowerShell v2+, 44 bytes
```
'rnbqknbr'
'p'*8
,('.'*8)*4
'P'*8
'RNBQKNBR'
```
Strings left on the pipeline are implicitly printed with `Write-Output` at program execution. We couple that with the default newline behavior for an array to produce the four lines of periods with the comma-operator.
```
PS C:\Tools\Scripts\golfing> .\draw-ascii-chess-board.ps1
rnbqknbr
pppppppp
........
........
........
........
PPPPPPPP
RNBQKNBR
```
[Answer]
# Ruby, ~~45~~ 44
1 byte saved thanks to tuxcrafting.
```
puts"rnbqkbnr",?p*8,[?.*8]*4,?P*8,"RNBQKBNR"
```
This is 45
```
puts s="rnbqkbnr",?p*8,[?.*8]*4,?P*8,s.upcase
```
Trying anything cleverer just seems to make it longer.
[Answer]
## JavaScript (ES6), ~~69~~ 65 bytes
*Saved 4 bytes thanks to edc65*
```
let f =
_=>`rnbqkbnr
p....PRNBQKBNR`.replace(/p|\./ig,c=>c.repeat(8)+`
`)
console.log(f());
```
[Answer]
# Cheddar, 56 bytes
```
a=['rnbqkbnr','p'*8]+['.'*8]*2->(a+a.rev=>@.upper).vfuse
```
Uses the new `=>` feature.
## Explanation
```
a=                      // set a to the first half
  ['rnbqkbnr','p'*8] +  // First two rows
  ['.'*8]*2             // Next two dots
->(
   a +
   a.rev=>@.upper       // Reverse and map all items to uppercase
).vfuse                 // Join on newlines
```
[Answer]
## Pyke, ~~28~~ ~~27~~ 26 bytes
```
"rnbqkbnr"i"P..p"1c8m*Xil3
```
[Try it here!](http://pyke.catbus.co.uk/?code=%22rnbqkbnr%22i%22P..p%221c8m%2aXil3)
I learned something new about my language today: `1c` can be used as a 2 char way of splitting a string into a list of characters.
```
"rnbqkbnr"i                - i = "rnbqkbnr"
                             stack = ["rnbqkbnr"])
           "P..p"1c        -  chunk("P..p", 1)
                             stack = ["rnbqkbnr", ["P", ".", ".", "p"]]
                   8m*     - map(8*>, ^)
                             stack = ["rnbqkbnr", ["PPPPPPPP", "........", "........", "pppppppp"]]
                      X    - splat(^)
                             stack = ["rnbqkbnr", "pppppppp", "........", "........", "PPPPPPPP"]
                       il3 - i.changecase()
                             stack = ["rnbqkbnr", "pppppppp", "........", "........", "PPPPPPPP", "RNBQKBNR"]
                           - implicit join with newlines
rnbqkbnr
pppppppp
........
........
PPPPPPPP
RNBQKBNR
```
[Answer]
# C#, 94 92 bytes
*Edit: Thanks to [milk](https://codegolf.stackexchange.com/users/58106/milk) for saving 1 byte by changing string order to remove the return whitespace.*
*Edit: Saved 1 more byte by adding a dummy parameter (**x** instead of **()**) for the anonymous function and calling it with any object.*
```
x=>{string a="RNBQKBNR\n",b="PPPPPPPP\n",c="........\n";return(a+b).ToLower()+c+c+c+c+b+a;};
```
Full program using the above function:
```
using System;
namespace DrawAnASCIIChessBoard
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<object,string>f= x=>{string a="RNBQKBNR\n",b="PPPPPPPP\n",c="........\n";return(a+b).ToLower()+c+c+c+c+b+a;};
            Console.WriteLine(f(1));
        }
    }
}
```
C# is a very verbose language...
---
# C# full program, 131 bytes
```
class P{static void Main(){string a="rnbqkbnr\n",b="pppppppp\n",c="........\n";System.Console.Write(a+b+c+c+c+c+(b+a).ToUpper());}}
```
Ungolfed:
```
class P
{
    static void Main()
    {
        string a="rnbqkbnr\n",
            b="pppppppp\n",
            c="........\n";
        System.Console.Write(a+b+c+c+c+c+(b+a).ToUpper());
    }
}
```
[Answer]
# Commodore BASIC V2/V7 (Commodore C64/128, VIC-20, TheC64Mini) - 129 tokenized and BASIC bytes
```
 0n$=cH(13):a$="{clear}{ctrl+h}{ctrl+n}rnbqkbnr"+n$:p$="pppppppp"+n$:?a$p$;:fOi=0to3:?"........":nE:goS1:?p$a$:end
 1a$="RNBQKBNR"+n$:p$="PPPPPPPP"+n$:reT
```
This should be entered into BASIC on a Commodore 128 and saved, it will then load into the VIC/C64 okay (you may need `LOAD "CHESS",8,0` on the VIC-20), or use CBM PRG Studio. The reason for this is that I'm going over the 80/88 character limit in line `0` for the C64/VIC-20 respectively. The C128 allows a 160 PETSCII character limit, so with keyword abbreviations this could easily be > 160 character per BASIC line.
The `{clear}` character is achieved by `SHIFT` + `CLR/HOME`, whereas (in a string) `CTRL+H` disables the `SHIFT+C=` key to toggle between graphics and business mode, and `CTRL+N` changes the case to business mode in BASIC.
The resulting listing is as in the screen shot. Copy the listing above and paste it into `WinVICE` with a right-click on your mouse over the `VICE` window.
I've added the resulting output on the VIC-20 to prove that it'll load on that mighty micro as well.
[![Commodore 128 BASIC listing of PETSCII art chess board](https://i.stack.imgur.com/yNjDE.png)](https://i.stack.imgur.com/yNjDE.png)
[![VIC-20 PETSCII chess board simulator](https://i.stack.imgur.com/QXjs1.png)](https://i.stack.imgur.com/QXjs1.png)
[Answer]
## Haskell, 53 bytes
```
a="rnbkqbnr" 
unlines$a:map(<$a)"p....P"++["RNBKQBNR"]
```
`a` is used as the first line and to determine the length of strings made of `p`, `.` and `P` (-> `<$a`). . 
[Answer]
# [MATL](http://github.com/lmendo/MATL), 26 bytes
```
'rnbqkbnr' 'p..'!l8X"vtPXk
```
[Try it online!](http://matl.tryitonline.net/#code=J3JuYnFrYm5yJyAncC4uJyFsOFgidnRQWGs&input=)
### Explanation
```
'rnbqkbnr'   % Push this string (1√ó8 char array)
'p..'!       % Push this string transposed (3√ó1 char array)
l8X"         % Repeat 1√ó8 times: gives 3√ó8 char array
v            % Concatenate the two arrays vertically into a 4√ó8 char array
tP           % Duplicate and flip vertically
Xk           % Convert to uppercase. Implicitly display the two 4√ó8 arrays
```
[Answer]
# [J](http://jsoftware.com/), 34 bytes
```
(tolower,|.)4 8$'RNBQKBNR',8#'P..'
```
[Try it online!](https://tio.run/##y/r/PzU5I19BoyQ/J788tUinRk/TRMFCRT3IzynQ28kvSF3HQlk9QE9P/f9/AA)
[Answer]
# Ex, ~~66~~ 61 bytes
(not a language per se, but reproductible line-oriented editor)
```
a
rnbqkbnr
.
t.
%t.
%t.
2s/./p/g
7s/./P/g
8s/./\u&/g
3,6s/././g
x
```
Second version, shorter, and sure there's room for improvement while staying POSIX.
```
a
rnbqkbnr
.
t.
%t.
%t.
2,7s/./p/g
7,8s/./\u&/g
3,6s/././g
x
```
## usage notes
To [try online](https://www.tutorialspoint.com/unix_terminal_online.php), just launch `ex yourfilename` then paste the lines. The result will be viewable with `cat yourfilename`.
## ungolfed/explanation
It's a line oriented editor (which will serve our purpose here as we operate line by line), with commands following the general syntax "line/range command parameters" (so 3 colomns plus one for comment following)
```
    a         " append following lines until line with dot only
rnbqkbnr
.
    t .       " duplicate current line
              "rnbqkbnr
              "rnbqkbnr
%   t .       " duplicate the whole buffer (2 lines)
              "rnbqkbnr
              "rnbqkbnr
              "rnbqkbnr
              "rnbqkbnr
%   t .       " copy the whole buffer (4 lines)
              "rnbqkbnr
              "rnbqkbnr
              "rnbqkbnr
              "rnbqkbnr
              "rnbqkbnr
              "rnbqkbnr
              "rnbqkbnr
              "rnbqkbnr
2,7 s/./p/g   " from line 2 to 7, replace each character with lower P
              "rnbqkbnr
              "pppppppp
              "pppppppp
              "pppppppp
              "pppppppp
              "pppppppp
              "pppppppp
              "rnbqkbnr
7,8 s/./\u&/g " on lines 7 and 8, replace each character with its uppercase
              "rnbqkbnr
              "pppppppp
              "pppppppp
              "pppppppp
              "pppppppp
              "pppppppp
              "PPPPPPPP
              "RNBQKBNR
3,6 s/././g   " from line 3 to 6, replace each character with a dot
              "rnbqkbnr
              "pppppppp
              "........
              "........
              "........
              "........
              "PPPPPPPP
              "RNBQKBNR
    x         " write the buffer into file and close the editor
```
Commands have a full name and a shortcut used here, as we're golfing.
* `a` for `append`, to switch into input mode until a sole dot
* `s` for `substitute`, with parameters /RegExp/replacement/flags where the flag `g` here means all occurrences (instead of default first only)
* `t` initialy means *transfer* and is put for `copy` (the letter C was already used to *change*/replace line) with as parameter the line after one should copy (and the `.` is for the current)
* `x` for `xit` and is put for *exit* (the letter E was already used to *edit* a file)
That's all.
[Answer]
# Python 2, 68 bytes
Posting anyway although the above Python 2 version is shorter.
It would not have to be a one liner for the amount of bytes, just played with it.
```
x,y,z="rnbqkbnr\n","p"*8+"\n","."*8+"\n";print x,y,4*z,(y+x).upper()
```
[Answer]
# JavaScript (ES6), 73
`.toUpperCase` is simply too long
```
_=>`rnbqkbnr
${r=c=>c[0].repeat(8)+`
`,r`p`+(b=r`.`)+b+b+b+r`P`}RNBQKBNR`
```
```
O.textContent=(
  
_=>`rnbqkbnr
${r=c=>c[0].repeat(8)+`
`,r`p`+(b=r`.`)+b+b+b+r`P`}RNBQKBNR`
)()
```
```
<pre id=O></pre>
```
[Answer]
# [V](http://github.com/DJMcMayhem/V), ~~27~~, 26 bytes
```
i¬∏P
RNBQKBNR√§kgujddpp√í.4√Ñ
```
[Try it online!](http://v.tryitonline.net/#code=acK4UApSTkJRS0JOUhvDpGtndWpkZHBww5IuNMOE&input=)
This contains some unprintable characters, so here is the readable version:
```
i¬∏P
RNBQKBNR<esc>√§kgujddpp√í.4√Ñ
```
where `<esc>` represents `0x1B`. Explanation:
```
i                               " Enter insert mode
 ¬∏P                             " Enter 8 'P' characters
                                " and a newline
RNBQKBNR<esc>                   " Enter the first row and escape to normal mode.
             √§k                 " Duplicate this line and the line above
               guj              " Convert this line, and the line below to lowercase
                  dd            " Delete this line
                    pp          " And paste it twice below us
                      √í.        " Replace this whole line with '.' chars
                        4√Ñ      " And create four copies of this line
```
[Answer]
# Emotinomicon, 89 bytes
Sadly Emotinomicon has nothing like an duplicate stack function. Would be usefull. But at least shorter than Java. :)
```
üò≠RNBKQBNR
PPPPPPPP
........
........
........
........
pppppppp
rnbkqbnrüò≤‚è™‚è¨‚è©
```
Explanation:
```
üò≠(...)üò≤‚è™‚è¨‚è©
üò≠(...)üò≤            String literal
         ‚è™  ‚è©      Loop
           ‚è¨        Pop one char and output
```
[Answer]
## Python 3.5, 56 bytes
```
for r in['rnbqkbn',*'p....P','RNBQKBN']:print((r*8)[:8])
```
This uses [an idea by zawata](https://codegolf.stackexchange.com/a/95965/20260) to encode each line as `(r*8)[:8]`, with a string repeated 8 times and trimmed to length `8`. The pawns and empty rows are just `'p'*8`, `'.'*8`, and `'P'*8`, with no trimming. The first row uses `'rnbqkbn'`, with `('rnbqkbn'*8)[:8]` including another rook on the right when multiplied and trimmed. The last row is the same but capitalized.
We express the list of row-parts compactly `['rnbqkbn','p','.','.','.','.','P','RNBQKBN']` using [Python 3.5's generalized unpacking](https://www.python.org/dev/peps/pep-0448/). We write out the first and last-entries, and the remaining single-character ones are unpacked from a string.
In Python 2, we could settle for `split` instead for 60 bytes:
```
for i in'rnbqkbn p . . . . P RNBQKBN'.split():print(i*8)[:8]
```
[Answer]
# C, 87 bytes
```
#define E "........\n"
main(){puts("rnbqkbnr\npppppppp\n"E E E E"PPPPPPPP\nRNBQKBNR");}
```
This uses preprocessor and string literal joining. Sorry, Matthew Greci and CSM, I don't have any reputation here to comment on your solution
[Answer]
## Python 3, 59 bytes
```
print('rnbqkbnr','p'*8,*['.'*8]*4,'P'*8,'RNBQKBNR',sep='\n')
```
Interesting that with better unpacking and print function, Python 3 can be much better than Python 2 for golf
This was based on <https://codegolf.stackexchange.com/a/95758/2212>
[Answer]
# [Vyxal `J`](https://github.com/Vyxal/Vyxal), ~~26 24 31 28~~ 25 bytes
-2 bytes thanks to the `j` flag.  
+7 bytes, added code to swap Q and K to make it valid.  
-3 bytes thanks to Aaron Miller!  
-3 bytes thanks to Kevin Cruijssen
```
¬´√¶‚â†‚Å∫tO¬´\p8*\.8*:W‚Åã·∏Ç‚áß‚ÄõKQ·∏ÇV
```
## Explanation
```
¬´√¶‚â†‚Å∫tO¬´                         - Push "rnbqkbnr"
       \p8*                     - Push "pppppppp"
           \.8*:                - Push "........" twice
                W‚Åã              - Listify, then join by \n
                  ·∏Ç‚áß            - Bifurcate and uppercase the second half
                    ‚ÄõKQ·∏ÇV       - Replace "KQ" with "QK"
<flag>                          - Join by newlines and print entire stack implicitly
```
[Try it Online!](https://lyxal.pythonanywhere.com?flags=J&code=%C2%AB%C3%A6%E2%89%A0%E2%81%BAtO%C2%AB%5Cp8*%5C.8*%3AW%E2%81%8B%E1%B8%82%E2%87%A7%E2%80%9BKQ%E1%B8%82V&inputs=&header=&footer=)
[Answer]
# Powershell, ~~82~~ 73 bytes
```
$x=("rnbqkbnr",$("p"*8),$("."*8),$("."*8));$x+$x[3..0].ToUpper()-join"`n"
```
[Answer]
# GNU sed, 54 bytes
```
s:^:rnbqkbnr:p;h
s:.:p:gp;G
h;s:[^\n]:.:gp;G
s:.:\U&:g
```
[**Try it online!**](http://sed.tryitonline.net/#code=czpeOnJuYnFrYm5yOnA7aApzOi46cDpncDtHCmg7czpbXlxuXTouOmdwO0cKczouOlxVJjpn&input=)
**Explanation:**
The black pieces are printed first, saving the two associated board ranks in reverse order in the hold space. The white pieces are printed by converting the hold space to uppercase letters.
```
s:^:rnbqkbnr:p;h   # change pattern and hold spaces to 'rnbqkbnr' and print string
s:.:p:gp           # replace each pattern space letter with a 'p', then print
G;h                # append hold space, then copy pattern space to hold space
s:[^\n]:.:gp       # replace each pattern space letter with a '.', then print
G;s:.:\U&:g        # append hold space and convert pattern space to uppercase
                   # (automatic printing of pattern space at the end)
```
[Answer]
# [Brain-Flak](https://github.com/DJMcMayhem/Brain-Flak), ~~366~~ 350 + 3 = 353 bytes
[Try it online!](http://brain-flak.tryitonline.net/#code=KCgoKCgoKCgoKCgoKSgpKCkpKXt9KCgoKHt9KSkpe317fSgoWygoKHt9KSl7fSl7fV0oKFsoe30oKSldKCgoKCgoe30oKSl7fSl7fSl7fSgpKXt9KTw-KSk8Pik8Pik8PikpKTw8Pih7fTw-KTw-KHt9PD4pPD4oe308PikoW10oKSgpKT5bKCldKSkpKSkpKSkoKCkoKSgpKCkpeyh7fVsoKV08KCgoKCgoKCgoKCgoKCkoKSgpKCkoKSl7fSkoKSl7fSgpKXt9KSkpKSkpKSk-KX17fSgoKCgpKCkoKSgpKCkpe30pPCgoKCgoKCgoKFtdW10oKSgpKCkoKSkpKSkpKSkpPD4pPD4-KSgoKCgoKCkoKSgpKSkpe30pKCh7fXt9KSgoW3t9KHt9KV0oKFt7fSgpXSg8Pih7fSgpKCkpPD4pPD4pPD4pPD4pPD4pKSl7PD4oe308Pil9e30&input=&args=LUE+LWQ)
```
(((((((((((()()())){}(((({}))){}{}(([((({})){}){}](([({}())](((((({}()){}){}){}()){})<>))<>)<>)<>)))<<>({}<>)<>({}<>)<>({}<>)([]()())>[()]))))))))(()()()()){({}[()]<((((((((((((()()()()()){})()){}()){}))))))))>)}{}(((()()()()()){})<((((((((([][]()()()()))))))))<>)<>>)(((((()()()))){})(({}{})(([{}({})](([{}()](<>({}()())<>)<>)<>)<>)<>))){<>({}<>)}{}
```
This gets a plus 3 because it requires the `-A` flag to run properly.
## Explanation
```
First we push the last 5 letters to the active stack.
We also push copies of last 3 numbers to the inactive stack.
This is done with fairly simple methods I won't go into for the sake of brevity.
 (((()()())){}(((({}))){}{}(([((({})){}){}](([({}())](((((({}()){}){}){}()){})<>)<><>)<>)<>)<>)))
We Move Everything from the offstack to the onstack.
The first 3 letters are the same as the last 3 letters in the first line
{<>({}<>)}{}
We push 10 for a new line
((()()()()()){})
Using the value of Q we create a P and push it 8 times
((((((((<...>[()]))))))))
We loop 4 times each time pushing 8 dots and a newline
(()()()())
{({}[()]<
    ((((((((((((()()()()()){})()){}()){}))))))))
>)}{}
We push the last two lines in a very similar way to the first two.
(((()()()()()){})<((((((((([][]()()()()))))))))<>)<>>)(((()()()){})(({}()()())(([{}(()()())](([{}()](<>({}()())<>)<>)<>)<>)<>))){<>({}<>)}{}
```
[Answer]
# Python 3, 82 80 75 Bytes
Not the shortest answer in python but it's my first and i think its pretty good for a first time
```
print('\n'.join((i*8)[:8]for i in'rnbqkbn p . . . . P RNBQKBN'.split()))
```
[Answer]
# C, ~~112~~ 109
```
char *e="rnbqkbnr";main(a){for(;a<65;)putchar((a++-1)%9?a<11?e[a-3]:a<20?112:a<48?46:a<57?80:e[a-57]-32:13);}
```
---
Readable:
```
char *e="rnbqkbnr";
main(a){
    for(;a<65;)
        putchar((a++-1)%9?a<11?e[a-3]:a<20?112:a<48?46:a<57?80:e[a-57]-32:13);
}
```
Notes:  
‚Ä¢char 13 = new line  
‚Ä¢char 112 = 'p'  
‚Ä¢char 46 = '.'  
‚Ä¢char 80 = 'P'  
‚Ä¢lowercase char-32 = UPPERCASE CHAR  
Thoughts: It's annoying because this is very well golfed for a short solution, but at the same time I could have gone sub-100 in my byte count by just hard coding in most of the chess board and just repeating the `.` `.` `.` part with a puts loop. But that's a very boring answer
---
Thanks @Ahemone for 3 bytes off!
]