[Question]
  [
... Not that you would, would you? The task is simple, output the following text:
```
 ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ________ 
||` |||1 |||2 |||3 |||4 |||5 |||6 |||7 |||8 |||9 |||0 |||- |||= |||BS    ||
||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||______||
|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/______\|
 ________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ 
||TAB   |||Q |||W |||E |||R |||T |||Y |||U |||I |||O |||P |||[ |||] |||\ ||
||______|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__||
|/______\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|
 _________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ________ 
||CAPS   |||A |||S |||D |||F |||G |||H |||J |||K |||L |||; |||' |||ENTER ||
||_______|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||______||
|/_______\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/______\|
 ___________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ___________ 
||SHIFT    |||Z |||X |||C |||V |||B |||N |||M |||, |||. |||/ |||SHIFT    ||
||_________|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||_________||
|/_________\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/_________\|
```
This is the keyboard of the future because in the future spaces are irrelevant, so are spacebars.
---
To make things a little bit easier on you:
1. `0123456789ABC...XYZ-=[]\;',./` - These chars are on keys of length 6 (including padding).
2. `TAB / BS / ENTER` - These keys are of length 10 (including padding).
3. `CAPS` - This key is of length 11 (including padding).
4. `SHIFT` - This key is of length 13 (including padding, on both sides).
---
Each individual key looks more or less like this:
```
 ____ 
||* ||
||__||
|/__\|
```
However, you should make note that two consecutive keys are not:
```
 ____  ____ 
||* ||||* ||
||__||||__||
|/__\||/__\|
```
But they are "conjoined":
```
 ____ ____ 
||* |||* ||
||__|||__||
|/__\|/__\|
```
This challenge shouldn't be too bad, best of luck to you; don't miss out on abusing the repetition! But don't underestimate the "special" keys either ;).
---
# Winning?
Shortest code wins because it's [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") you know.
  
[Answer]
# [V](https://github.com/DJMcMayhem/V), ~~189, 179, 175, 164, 161, 157, 155, 149, 145, 141~~, 135 bytes
```
¬¨19√â`A0-=BS¬¥ 
TAB¬≥ qwertyuiop[]\
CAPS¬≥ asdfghjkl;'ENTER 
SHIFT¬¥ √ÑJizxcvbnm,./√ç„A-Z ]/√ï& 
√ç√ì¬´√º$/|||&
√≤√ô√ì„|]/_
√ô√ì√ó¬´/√ú|¬Ø
kkP√ì/_ _
k√≤√éx$x
```
[Try it online!](https://tio.run/##K/v//9AaQ8vDnQmOBrq2TsGHtihwhTg6HdqsUFieWlRSWZqZXxAdG8Pl7BgQDBRMLE5JS8/Iys6xVnf1C3ENUuAK9vB0CwHqkj7c4pVZVZFclpSXq6OnL32491CLo26UQqz@4alqClyHew9PPrT68B4V/ZqaGjWuw5sOzwQKtNTE6sdzgZiHpx9arX94Ts2h9VzZ2QGHJ@vHK8RzZQOV9VWoVPz/DwA "V ‚Äì Try It Online")
*This answer is now tweetable!*
---
[Watch it run!](https://i.stack.imgur.com/gBpOD.gif) This is a slightly modified version that updates as it runs so you can sorta see how it works. This is an outdated version since I haven't gotten around to re-recording it yet, but the general approach is identical.
This is probably the longest V answer ever written. It certainly didn't help that V's interpreter is extremely slow. It took me around an hour to write the first revision, but I've been repeatedly coming back to it to shave a couple bytes off each time. Since the full keyboard is 1215 bytes, currently this answer is 91% shorter than the output, so I'm pretty happy with the results.
Since this contains some unprintable characters, and a lot of gross non-ASCII, here's a hexdump:
```
00000000: ac31 39c9 6041 302d 3d42 53b4 200a 5441  .19.`A0-=BS. .TA
00000010: 42b3 2071 7765 7274 7975 696f 705b 5d5c  B. qwertyuiop[]\
00000020: 0a43 4150 53b3 2061 7364 6667 686a 6b6c  .CAPS. asdfghjkl
00000030: 3b27 454e 5445 5220 0a53 4849 4654 b420  ;'ENTER .SHIFT. 
00000040: 1bc4 4a69 7a78 6376 626e 6d2c 2e2f 1bcd  ..Jizxcvbnm,./..
00000050: 8441 2d5a 205d 2fd5 2620 0acd d3ab fc24  .A-Z ]/.& .....$
00000060: 2f7c 7c7c 260a f2d9 d384 7c5d 2f5f 0ad9  /|||&.....|]/_..
00000070: d3d7 ab2f dc7c af0a 6b6b 50d3 2f5f 205f  .../.|..kkP./_ _
00000080: 0a6b f2ce 7824 78                        .k..x$x
```
## How the heck does it work?
Alright, this explanation is gonna be a doozy. You ready? First off, we need enter the letters so we can build up the keys around them. This is
```
¬¨19√â`A0-=BS¬¥ 
TAB¬≥ qwertyuiop[]\
CAPS¬≥ asdfghjkl;'ENTER 
SHIFT¬¥ <esc>√ÑJizxcvbnm,./<esc>
```
Which inserts:
```
`1234567890-=BS    
TAB   qwertyuiop[]\
CAPS   asdfghjkl;'ENTER 
SHIFT    zxcvbnm,./SHIFT  
```
It enters it pretty straightforward, but there are a few tricks that we use to save characters. For example, `¬¨19` enters "123456789", `¬≥`  enters three spaces, and we duplicate the shift so that we don't need to enter it multiple times.
Note how the letters are lowercase here. This is so that we can easily distinguish between the uppercase keys like "ENTER" and the single letters. Writing them this way makes it easier to tell which characters to put a bar before, and only adds one byte to convert them to lowercase later. So we do a substitute command to convert these to uppercase, and add one space after each of them:
```
√ç               " Globally replace
 [^A-Z ]        " Anything but a uppercase alphabet character or a space
        /       " with
         √ï&     " The matched pattern made uppercase, followed by a space
```
Now, we take each key sequence (any run of non-whitespace), and put three bars before and after them:
```
√ç           " Globally replace
 √ì¬´         "   Any number of non-space characters
   √º        "   or
    $       "   an end of line
     /      " with
      |||   "    Three bars 
         &  "    And the matched pattern
```
At this point, the buffer looks like this:
```
|||` |||1 |||2 |||3 |||4 |||5 |||6 |||7 |||8 |||9 |||0 |||- |||= |||BS    |||
|||TAB   |||Q |||W |||E |||R |||T |||Y |||U |||I |||O |||P |||[ |||] |||\ |||
|||CAPS   |||A |||S |||D |||F |||G |||H |||J |||K |||L |||; |||' |||ENTER |||
|||SHIFT    |||Z |||X |||C |||V |||B |||N |||M |||, |||. |||/ |||SHIFT    |||
```
Having three bars on the first and last columns is actually very convenient and ends up saving many bytes in the long run.
And here is where we run one giant loop. This will convert something like this:
```
|||SHIFT    |||Z |||X |||C |||V |||B |||N |||M |||, |||. |||/ |||SHIFT    |||
```
into something like this:
```
 ___________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ___________ 
||SHIFT    |||Z |||X |||C |||V |||B |||N |||M |||, |||. |||/ |||SHIFT    ||
||_________|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||_________||
|/_________\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/_________\|
```
Everything between two instances of `√≤` will run until an error happens, which will happen when we try to go up into a line that does exist yet. Since we just ran a *globally substitute* command, our cursor is on the last line, and we'll transform these working our way up.
```
√≤         " Recursively:
 √ô        "   Duplicate this line
  √ì       "   Substitute all on this line:
   [^|]   "     Anything but a bar
       /  "   With:
        _ "     An underscore
```
This is the
```
|||_________|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||_________|||
```
line.
```
√ô         "   Duplicate this line
 √ì        "   Subsitute all on this line:
  √ó¬´      "     A run of *non-word characters* (that is, [^0-9A-Za-z_])
    /     "   With:
     √ú|¬Ø  "     '\|/'
```
This is the
```
\|/_________\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/_________\|/
```
Line.
```
kk        "   Move up two lines (to the original text with "SHIFT")
  P       "   Paste the last line we duplicated (the one with all the underscores)
   √ì      "   Substitute:
          "     Since we don't give any regex here, it re-uses the last one 
          "     (a run of *non-word* characters)
    /     "   With:
     _ _  "     '_ _'
```
This is the:
```
_ ___________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ___________ _
```
Line.
```
k         "   Move up a line (this will throw an error, breaking the loop when we're done)
 √≤        " Endwhile
```
Now we have the full keyboard, but each line contains either an extra bar, an extra slash (forward or backward), or an extra underscore. *Super* easy fix
```
√é             " On every line:
 x            "   Delete a character
  $           "   Move to the end of the line
   x          "   and delete another character
```
After all that madness, the buffer is implicitly printed.
[Answer]
# Lua 5.3, ~~416~~ 394 Bytes.
```
k="` 1 2 3 4 5 6 7 8 9 0 - = BS|TAB Q W E R T Y U I O P [ ] \\|CAPS A S D F G H J K L ; ' ENTER|SHIFT Z X C V B N M , . / SHIFT"S={TAB=6,BS=6,ENTER=6,CAPS=7,SHIFT=9}for v in k:gmatch"[^|]+"do for i=1,4 do for s in v:gmatch"%S+"do l=S[s]or 2j=("_"):rep(l)io.write(i==1 and" _"..j.."_"or i==2 and"||"..s..(" "):rep(l-#s).."|"or i==3 and"||"..j.."|"or"|/"..j.."\\")end print(i>1 and"|"or"")end end
```
## Ungolfed and with comments.
```
keys="` 1 2 3 4 5 6 7 8 9 0 - = BS|TAB Q W E R T Y U I O P [ ] \\|CAPS A S D F G H J K L ; ' ENTER|SHIFT Z X C V B N M , . / SHIFT" -- Define a keyboard. Separated with |'s, there's probably a nicer way to do this, but I'm not sure about how to yet.
special_keys={TAB=6,BS=6,ENTER=6,CAPS=7,SHIFT=9} -- Special keys get special definitions
for v in keys:gmatch"[^|]+" do -- For each row on the keyboard...
    for i=1, 4 do -- Each of the 4 rows per key...
        for s in v:gmatch"%S+" do -- Match each individual key.
            l=special_keys[s]or 2 j=("_"):rep(l) -- l is the length of the key, j is "_" repeated length times, which is used a bit.
            io.write(i==1 and -- Lua needs Switch Statements!
                     " _"..j.."_" -- The top of the key is a Space, then j with two _'s around it.
                     or
                     i==2 and
                     "||"..s..(" "):rep(l - #s).."|" -- Second row is || then the key, then the remaining whitespace, and then one more |, which chains together.
                     or
                     i==3 and
                     "||"..j.."|" -- Third row is like the second, but without the key. Instead of whitespace, uses j, which is the underlines.
                     or
                     "|/"..j.."\\") -- Last row is like the third row, but with "|/" and "\" instead of "||" and "|"
        end
        print(i>1 and"|"or"") -- First line is the only line that doresn't need a "|", everything else gets a "|" before the newline.
    end
end
```
## Output
```
 ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ________
||` |||1 |||2 |||3 |||4 |||5 |||6 |||7 |||8 |||9 |||0 |||- |||= |||BS    ||
||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||______||
|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/______\|
 ________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____
||TAB   |||Q |||W |||E |||R |||T |||Y |||U |||I |||O |||P |||[ |||] |||\ ||
||______|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__||
|/______\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|
 _________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ________
||CAPS   |||A |||S |||D |||F |||G |||H |||J |||K |||L |||; |||' |||ENTER ||
||_______|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||______||
|/_______\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/______\|
 ___________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ___________
||SHIFT    |||Z |||X |||C |||V |||B |||N |||M |||, |||. |||/ |||SHIFT    ||
||_________|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||_________||
|/_________\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/_________\|
```
I'm going to get destroyed by other langauges, but I thought I'd give this a shot. Nice amount of complexity, and atleast it's shorter than the keyboard!
[Answer]
# [Bubblegum](https://esolangs.org/wiki/Bubblegum), 191 bytes
```
0000000: ad d2 35 7a c6 30 10 06 e1 5e a7 50 15 66 fe 99  ..5z.0...^.P.f..
0000010: c1 8c 61 50 0e b2 87 8f 27 24 f7 eb af 78 2b e3  ..aP....'$...x+.
0000020: 3c b2 ae 99 1a 66 8d c8 a7 15 91 73 b8 80 4b b8  <....f.....s..K.
0000030: 82 6b b8 81 5b b8 83 1e 9c c1 31 8c 60 5e d9 66  .k..[.....1.`^.f
0000040: 22 46 c4 39 d1 c2 78 d6 a9 73 6f 5a d8 9b 18 ff  "F.9..x..soZ....
0000050: bb 5a e8 55 cf e6 fc ae 48 01 8f b0 82 12 6a 78  .Z.U....H.....jx
0000060: 86 7b 08 20 83 1c 5e e1 1d de e8 e5 7f 57 b4 d0  .{. ..^......W..
0000070: 8b a9 9b f9 5e 5d 9d af c5 2c af 7e 82 cd a0 82  ....^]...,.~....
0000080: 25 ac 61 03 5b 08 21 82 18 06 b0 0b ab b4 5e 95  %.a.[.!.......^.
0000090: ad 5e 5d 9d 2f d6 e9 f9 d2 c4 f2 bd aa 6d b0 ae  .^]./........m..
00000a0: ed 4f b1 17 78 82 05 3c c0 1c 52 48 e0 08 4e e0  .O..x..<..RH..N.
00000b0: 14 5a 77 fb 5e aa 58 be 97 aa 98 bf db 7c 01     .Zw.^.X......|.
```
[Try it online!](https://tio.run/nexus/bubblegum#RZPLqtVAEEXnfsVWFAdK2d1Jv8SxCIJeBFGOeLCfA0UcOPCi4q9fa3fO1QxCE5JVq3ZVbsxxPUXp6A6bRyxoAZuBNTABw8IPlAivTzxCwBzIGRDxP8WIyFmuZIrcWSCrqGaRGoLlJ2agOqSINOEi3I4ZMSrKRExwFWMjqlwpSB7e19v1owvKKWpr/LysiraweupoiT4qky3ihpqQDPbKA56RM3mT7yIvL6hNUckhrHeSih2HDVbJjcLb4WzYbM8sBPki8mGRrHw6yzxQu6Kcwx7QdmwZ3aI59tIDSqZPmPAFPSFX2IQ5gXvPJWtn6vTtROCB8oqqlS@PBO/RJobG29jvnmAsQ6uG5lblC6tATvKWiBfL7PP1gQpsMCBWGE3VrNYae9HxWZ3sYImhw1W3iLqjG0X9EnB863p3axWJquxF/WcmxHfkzpE1D9fW7Aatmj5ceiDh/FFvj@XP/wYTs/IoaxnMxtipZ1dHidul3RmtVamkhbIHHkjR2O8eVmp3oPKxov9k3GTgI9NQ91ZnMR2q@uiSdGI1Q1DpyQUkX2@tiqJGx67ZajiRqaqP8Vy2ZlZujvkPQ9t98AB5vean6/VGk391QVVF2Z0TjBGzrj@lwCdU7SXynPWsqhWxcaC85PRD23p/WP2Wm5u/ "Bubblegum ‚Äì TIO Nexus")
[Answer]
## Haskell, 263 chars (353 bytes UTF-8)
```
import Data.List
main=mapM_ putStrLn$transpose.foldr k[g]=<<
 [s"`1234567890-="%"   ‚Üê"
 ,"‚Üπ   ":s"ùëÑùëäùê∏ùëÖùëáùëåùëàùêºùëÇùëÉ[]\\"
 ,"‚á©    ":s"ùê¥ùëÜùê∑ùêπùê∫ùêªùêΩùêæùêø;'"%"     ‚Üµ"
 ,"‚áß       ":s"ùëçùëãùê∂ùëâùêµùëÅùëÄ,./"%"       ‚áß"]
r%e=r++[e]
g=" |||"
k s r=g:"_||/":['_':c:"__"|c<-s]%"_||\\"++r
s=map(:" ")
```
[![screenshot of that keyboard](https://i.stack.imgur.com/KcN5e.png)](https://i.stack.imgur.com/KcN5e.png)
As there has been a lot of discussion about the score in light of these unicode characters... here's the same program, reduced to all-ASCII:
## Haskell, 263 chars (263 bytes UTF-8)
```
import Data.List
main=mapM_ putStrLn$transpose.foldr k[g]=<<
 [s"`1234567890-="%"BS  "
 ,"TAB ":s"QWERTYUIOP[]\\"
 ,"CAPS ":s"ASDFGHJKL;'"%"ENTER "
 ,"SHIFT   ":s"ZXCVBNM,./"%"SHIFT   "]
r%e=r++[e]
g=" |||"
k s r=g:"_||/":['_':c:"__"|c<-s]%"_||\\"++r
s=map(:" ")
```
[Answer]
# PHP, 303 bytes
Lazy but effective. :)
```
<?=gzinflate(base64_decode('rdO5DoJAEIDhnqegs/G+jbEAvA88wBuzPsg8vPyLZo3tOMUXmt1k/iy+ycfXYj88kacvIg1oQgva0IEu9KAPA6hDBUYQJn4+IvldxogWhrtqxmRamEw8t66afMc0CO26soczTOAAKVzhCAvYwg7u8IDs06tYVx3Oc+uqw7lef3lfUbBLimABJDCGKcxgDktYwRqGULJ143Ry+O71r/elDvb7vnSx3r2S+WKaFn+U3OACEZzs7wYxbKAMVajZvO6066WK9dNLFcuefgE'));
```
[Answer]
# Python 3.5+, 239 bytes
```
s="SHIFT   "
for k in[(*"`1234567890-=","BS   "),("TAB  ",*"QWERTYUIOP[]\\"),("CAPS  ",*"ASDFGHJKL;'","ENTER"),(s,*"ZXCVBNM,./",s)]:
 for f in"{1}__ ,|{} ||,|{1}||,/{1}\|".split(","):print(f[-1]+"".join(f.format(c,"_"*-~len(c))for c in k))
```
[Answer]
## Batch, ~~465~~ 452 bytes
```
@echo off
call:c _ ` 1 2 3 4 5 6 7 8 9 0 - "=" "BS   " _____
call:c _____ "TAB  " Q W E R T Y U I O P [ ] \ _
call:c ______ "CAPS  " A S D F G H J K L ";" ' ENTER _____
call:c ________ "SHIFT   " Z X C V B N M "," . / "SHIFT   " ________
exit/b
:c
set t=%1_
set s=!!%~2 !!!%3 !!
:l
set t=%t%#__
set s=%s%!%~4 !!
shift
if not "%~5"=="" goto l
set t=%t%#%4_
for %%l in (" _%t:#=_ _%_" "%s:!=|%" "||%t:#=|||%||" "|/%t:#=\|/%\|")do echo %%~l
```
The `:c` subroutine handles a line of keys. Keys containing extra spaces need to be quoted, as do the `=`, `;`, `,` keys, possibly due to a bug in the `shift` command. The first and last parameters are strings of `_`s of the same length as the first and last key to aid concatenation. `t` then ends up as the `_`s common to the first, third and fourth rows, with `#`s marking the join, which are replaced appropriately before the leading and trailing characters are added, while `s` is the second row, but with `|`s changed to `!`s as they reduce the number of `"`s that I need. Edit: Saved 1 byte by printing all four lines in a single statement, and 12 bytes by optimising the way I assigned the `s` variable.
[Answer]
# Ruby, 226 bytes
```
16.times{|i|puts (([[?`,'TAB  ','CAPS  ',s='SHIFT   '][j=i/4]]+%w{1234567890-= QWERTYUIOP[] ASDFGHJKL;' ZXCVBNM,./}[j].chars+[['BS   ',?\\,'ENTER',s][j]]).map{|e|e.tr('^|'[-i%4/3,2],?_)}*3*"__ _ |||_|||_\\|/"[i%4*4,4])[72,75]}
```
Improvements as follows:
1.No empty string elements at the beginning and end of the array. Instead the array is triplicated making 3 side-by side keyboards. After conversion to string we have 3 keyboards with outer edges missing. This is truncated to only display the middle one, complete with edges.
2.Changed version of Ruby. Used Ideone instead of 1.9.3 installed on my machine. This means `.chars.to_a` can be shortened to just `.chars`.
# Ruby, 239 bytes
There's a few more bytes to be golfed out of this. Will look tomorrow.
```
16.times{|i|puts ((['']+[[?`,'TAB  ','CAPS  ',s='SHIFT   '][j=i/4]]+%w{1234567890-= QWERTYUIOP[] ASDFGHJKL;' ZXCVBNM,./}[j].chars.to_a+[['BS   ',?\\,'ENTER',s][j]]+['']).map{|e|e.tr('^|'[-i%4/3,2],?_)}*"__ _ |||_|||_\\|/"[i%4*4,4])[2..-2]}
```
**ungolfed**
```
16.times{|i|                                                            #iterate throug 16 lines of output
  puts ((['']+[[?`,'TAB  ','CAPS  ',s='SHIFT   '][j=i/4]]+              #build row from blank element plus left special key
    %w{1234567890-= QWERTYUIOP[] ASDFGHJKL;' ZXCVBNM,./}[j].chars.to_a+ #plus regular keys
   [['BS   ',?\\,'ENTER',s][j]]+['']).map{|e|                           #plus right special key and another blank element
                                      e.tr('^|'[-i%4/3,2],?_)}*         #if i%4 != 1, replace the keytop legend with _ characters 
   "__ _ |||_|||_\\|/"[i%4*4,4])[2..-2]                                 #join the middle parts of the keys with ends. truncate spurious outer ends before printing.
}
```
[Answer]
# C#, 357 bytes (when in one line, and incorporating most suggestions)
---
```
var s="";
foreach(var r in@"`|1|2|3|4|5|6|7|8|9|0|-|=|BS   ~TAB  |Q|W|E|R|T|Y|U|I|O|P|[|]|\~CAPS  |A|S|D|F|G|H|J|K|L|;|'|ENTER~SHIFT   |Z|X|C|V|B|N|M|,|.|/|SHIFT   ".Split('~'))
for(int i=0;i<4;s+=i>0?"|\n":"\n",i++)
foreach(var k in r.Split('|'))
{
var u=new string('_',k.Length+1);
s+=i<1?" "+u+"__"
:i<2
?"||"+k+" |"
:i<3
?"||"+u+"|"
:"|/"+u+@"\";
}
Console.Write(s);
```
**Or, 353 with string interpolation and all other suggestions**
```
var s="";foreach(var r in@"`|1|2|3|4|5|6|7|8|9|0|-|=|BS   ~TAB  |Q|W|E|R|T|Y|U|I|O|P|[|]|\~CAPS  |A|S|D|F|G|H|J|K|L|;|'|ENTER~SHIFT   |Z|X|C|V|B|N|M|,|.|/|SHIFT   ".Split('~'))for(int i=0;i<4;s+=i>0?"|\n":"\n",i++)foreach(var k in r.Split('|')){var u=new string('_',k.Length+1);s+=i<1?$" {u}__":i<2?$"||{k} |":i<3?$"||{u}|":$@"|/{u}\";}Console.Write(s);
```
Ungolfed (without string interpolation):
```
var solution = "";
foreach (var row in @"`|1|2|3|4|5|6|7|8|9|0|-|=|BS   ~TAB  |Q|W|E|R|T|Y|U|I|O|P|[|]|\~CAPS  |A|S|D|F|G|H|J|K|L|;|'|ENTER~SHIFT   |Z|X|C|V|B|N|M|,|.|/|SHIFT   ".Split('~'))
for (int i = 0; i < 4; solution += i > 0 ? "|\n" : "\n", i++)
foreach (var key in row.Split('|'))
{
   var underscores = new string('_', key.Length + 1);
   solution += i < 1 ? " " + underscores + "__"
                     : i < 2
                     ? "||" + key + " |"
                     : i < 3
                     ? "||" + underscores + "|"
                     : "|/" + underscores + @"\";
}
Console.Write(solution);
```
[Answer]
## PowerShell v2+, 465 bytes
```
($b=($a=' ____')*10)+$a*3+" "+($d='_'*8)
"||``@$(1..9-join'@')@0@-@=@BS    ||
||$(($f=,'__'*10-join'#'))#__#__#__#$(($g='_'*6))||
$(($c=($e='|/__\')*10))$e$e$e|/$g\|
 $d$b$a$a$a
||TAB  @Q@W@E@R@T@Y@U@I@O@P@[@]@\ ||
||$g#$f#__#__#__||
|/$g\$c$e$e$e|
 _$d$b$a $d
||CAPS  @A@S@D@F@G@H@J@K@L@;@'@ENTER ||
||_$g#$f#__#$g||
|/_$g\$c$e|/$g\|
 ___$d$b ___$d
||SHIFT   @Z@X@C@V@B@N@M@,@.@/@SHIFT    ||
||___$g#$f#___$g||
|/___$g\$c|/___$g\|"-replace'@',' #'-replace'#','|||'
```
I'm halfway embarrassed to be posting this answer, given how short the PHP and Python answers are, nevermind the C# answer, but I'm unable to get this method shorter. Other approaches may yield better results.
It's basically just a giant multi-line string, with variables (`$a` and the like) substituting for various substrings, and a couple `-replace`s at the end to finish it out. Script blocks `$(...)` are inserted where necessary to introduce new variables.
[Try it online!](https://tio.run/nexus/powershell#PZDbbsIwDIbv@xRRaykNZzRp2jRV@oHBYAfGoDszhQKl2oS2add@d@bQgx0pcWJ//uNDSOsopCTSyoppU@t2TJ2S2kndV349pG2kra6dGc9nXq1AYbfVOm9@/Xx@a2iDDpqI0F8oMWaPmcKQdlFDC0tQeWKgjQmsLZbLyI7UU2OkxsUb0ZBGmtvWLnMNhlLn3KZsyZ6iLa0pcS494l5fKTzgGUPMEeMVj5jgHjO84wPLQkgW0K7q6q4cijYF11M2Zwpasge9mfwBPSxwiRGuMMY1bnCLC2gMp/FwnlNthaXsyLQFtBQqQ3TcfJeCxXgyimU4eMMLBnhCH1PcoYEW2igfC7at6Lak25xfnthv/qW/@2STyvQbWgW6igOJmVkfDv8 "PowerShell ‚Äì TIO Nexus")
[Answer]
**Python, ~~493~~ 458 Bytes.**
```
k=[['|']*75 for i in [0]*16]
v=' '
w='_'
y=0
def a(s,x,o):k[y+o][x:x+len(s)]=list(s)
def p(s,i,x):a(s+v*(i-len(s)),x+2,1);a(v+w*(i+2)+v,x,0);a(w*i,x+2,2);a(w*i,x+2,3);a('/',x+1,3);a('\\',x+i+2,3);return x+i+3
def q(s,x):return reduce(lambda a,b:p(b,2,a),list(s),x)
p('BS',6,q('`1234567890-=',0))
y=4
q('QWERTYUIOP[]\\',p('TAB',6,0))
y=8
p('ENTER',6,q('ASDFGHJKL;\'',p('CAPS',7,0)))
y=12
p('SHIFT',9,q('ZXCVBNM,./',p('SHIFT',9,0)))
for l in k:print''.join(l)
```
Functionally equivalent but somewhat more readable:
```
k=[['|']*75 for i in range(16)]
def a(s,x,y):k[y][x:x+len(s)]=list(s)
def p(s,i,x,y):
    a(s+' '*(i-len(s)),x+2,y+1)
    a(' '+'_'*(i+2)+' ',x,y)
    a('_'*i,x+2,y+2)
    a('_'*i,x+2,y+3)
    k[y+3][x+1]='/'
    k[y+3][x+i+2]='\\'
    return x+i+3
def q(s,x,y):return reduce(lambda a,b:p(b,2,a,y),list(s),x)
p('BS',6,q('`1234567890-=',0,0),0)
q('QWERTYUIOP[]\\',p('TAB',6,0,4),4)
p('ENTER',6,q('ASDFGHJKL;\'',p('CAPS',7,0,8),8),8)
p('SHIFT',9,q('ZXCVBNM,./',p('SHIFT',9,0,12),12),12)
for l in k:print ''.join(l)
```
Unfortunately it's already longer than the answer provided in Lua.
[Answer]
# PHP, ~~316~~ 312 bytes
```
foreach([($s=str_split)("`1234567890-=")+[13=>"BS   "],["TAB  "]+$s("_QWERTYUIOP[]\\"),["CAPS  "]+$s("_ASDFGHJKL;'")+[12=>ENTER],[$h="SHIFT   "]+$s("_ZXCVBNM,./")+[11=>$h]]as$r)for($y=-1;$y++<3;)foreach($r as$i=>$k)echo["\n".$a="| "[!$y]][$i],"_||/"[$y],str_pad($y-1?_:$k,strlen($k)+1,$y-1?_:" "),"_||\\"[$y],$a;
```
I¬¥m pretty sure that this approach cannot be golfed any further. But if anyone finds 10 more bytes ... :D  
Run with `-r`.
**breakdown**
```
foreach([                       // loop through rows
    ($s=str_split)("`1234567890-=")+[13=>"BS   "],
    ["TAB  "]+$s("_QWERTYUIOP[]\\"),
    ["CAPS  "]+$s("_ASDFGHJKL;'")+[12=>ENTER],
    [$h="SHIFT   "]+$s("_ZXCVBNM,./")+[11=>$h]
]as$r)
    for($y=-1;$y++<3;)          // loop through lines 0..3
        foreach($r as$i=>$k)    // loop through keys
            echo["\n".$a="| "[!$y]][$i],// first key in row: leading NL + space/pipe
                "_||/"[$y],             // key edges
                str_pad(
                    $y-1?_:$k,          // line 1: key label; else underscore
                    strlen($k)+1,       // pad to length+1
                    $y-1?_:" "),        // with spaces for label, underscores else
                "_||\\"[$y],            // more key edges
                $a                      // joining edges
            ;
```
[Answer]
# JavaScript (ES6), 286
An anonymous function with no parameters
```
_=>[..."`1234567890-=~~QWERTYUIOP[]\\~ASDFGHJKL;'~~ZXCVBNM,./~"].map(x=>(o+=`/${b='_'.repeat(w=x<y?2:' 667699'[x=["BS","TAB","CAPS","ENTER"][p++]||'SHIFT',p])}\\|`,m+=y+(x+'    ').slice(0,w)+y+y,n+=y+b+y+y,l+=' __'+b)[73]&&(k.push(l,m,n,o),l='',m=n=o=y),m=n=o=y='|',p=l=k=[])&&k.join`
`
```
*Less golfed*
```
_=>[..."`1234567890-=~~QWERTYUIOP[]\\~ASDFGHJKL;'~~ZXCVBNM,./~"]
  .map(x=>
      (
        w = x < y // special chars are marked '~' that is > '|'
            ? 2 // normal key, width 2
            : ( // else special key, set x and width
                // p should be incremented at next step, but I need to make it numeric as it starts as []
                x = ["BS","TAB","CAPS","ENTER"][p++]||'SHIFT',
                ' 667699'[p], // value for w (note p is off by 1)
              ),
        b = '_'.repeat(w), // bottom border (and top, almost)
        o +=`/${b}\\|`, //  line 4
        n += y+b+y+y,   //  line 3
        m += y+(x+'    ').slice(0,w)+y+y, // line 2
        l += ' __'+b    // top line, the border must be longer
      )[70] && // check if at end of row (check position in l)
         (
            k.push(l, m, n, o), // add lines to list
            l = '', // reset all
            m = n = o = y
         )
    , // initial setup
    // y stays fixed to '|', lines 2,3,4 start as '|'
    m = n = o = y ='|',
    // k is the lines array, l will become as string and starts empty
    // p is the index of current special key and will become numeric
    p = l = k = [] 
  ) 
  && k.join`\n` // return lines as a single string
```
```
F=_=>[..."`1234567890-=~~QWERTYUIOP[]\\~ASDFGHJKL;'~~ZXCVBNM,./~"].map(x=>(o+=`/${b='_'.repeat(w=x<y?2:' 667699'[x=["BS","TAB","CAPS","ENTER"][p++]||'SHIFT',p])}\\|`,m+=y+(x+'    ').slice(0,w)+y+y,n+=y+b+y+y,l+=' __'+b)[73]&&(k.push(l,m,n,o),l='',m=n=o=y),m=n=o=y='|',p=l=k=[])&&k.join`
`
O.textContent=F()
```
```
<pre id=O></pre>
```
[Answer]
# Bash (on OSX), ~~12~~ 8 + 221 + 1 = ~~234~~ 230 bytes
Yeah, I know, compression. But it works, no?
```
gunzip<f
```
Requires a file called "f" in the current directory with the following contents (put into base64 for PPCG-friendliness - you can decode this into the file "f" first.):
```
H4sIAHbPT1gAA63TuQ6CQBCA4Z6noLPxvo2xALwPPMAbsz7IPLz8i2aN7TjFFxo2mT+7vsnH12I/PJGnLyINaEIL2tCBLvSgDwOoQwVGECZ+PiL5WcaIFoazasZkWphMPLeumnzHNAjturKHM0zgAClc4QgL2MIO7vCA7NOrWFcdznPrqsO5Xn+5X1GwS4pgASQwhinMYA5LWMEahlCydeN0cvju9a/7pQ72e790sd69kvlimhYvSm5wgQhO9rlBDBsoQxVqNq/72/VSxfrppYpV9HoBoNfjQcAEAAA=
```
[Answer]
# [SOGL V0.12](https://github.com/dzaima/SOGL), ~~131~~ ~~128~~ 127 [bytes](https://github.com/dzaima/SOGL/blob/master/chartable.md) ([competing?](https://codegolf.meta.stackexchange.com/questions/12877/lets-allow-newer-languages-versions-for-older-challenges?cb=1))
```
‚Öü]y‚Äò9Œî√∏‚àë"`≈ó0-=‚ÄùƒçŒö"TAB  ‚ÄùQWERTYUIOP[]\‚Äùƒç+"oF¬´‚ñíŒí¬≤‚Äò‚Å∑Œü‚ÄòASDFGHJKL;'‚ÄùƒçŒö+"_‚ÑñK¬≥‚ÄòZXCVBNM,./‚Äùƒç‚Å¥++¬π{"^Œº¬≥‚Äòƒç;{U;"_||/‚Äù‚îº;{"_≈ó__‚Äù‚îº}"Œü  œà¬¶‚ÑÆ¬≥‚Äò‚îº}O
```
SOGL does have the [`2*2/`](https://github.com/dzaima/SOGL/blob/master/P5ParserV0_12/data/charDefs.txt#L76) and [`2/2*`](https://github.com/dzaima/SOGL/blob/master/P5ParserV0_12/data/charDefs.txt#L86) quirks, but those feel too much like a built-in for this challenge.  
[Try it Here!](https://dzaima.github.io/SOGLOnline/?code=JXUyMTVGJTVEeSV1MjAxODkldTAzOTQlRjgldTIyMTElMjIlNjAldTAxNTcwLSUzRCV1MjAxRCV1MDEwRCV1MDM5QSUyMlRBQiUyMCUyMCV1MjAxRFFXRVJUWVVJT1AlNUIlNUQlNUMldTIwMUQldTAxMEQrJTIyb0YlQUIldTI1OTIldTAzOTIlQjIldTIwMTgldTIwNzcldTAzOUYldTIwMThBU0RGR0hKS0wlM0IlMjcldTIwMUQldTAxMEQldTAzOUErJTIyXyV1MjExNkslQjMldTIwMThaWENWQk5NJTJDLi8ldTIwMUQldTAxMEQldTIwNzQrKyVCOSU3QiUyMiU1RSV1MDNCQyVCMyV1MjAxOCV1MDEwRCUzQiU3QlUlM0IlMjJfJTdDJTdDLyV1MjAxRCV1MjUzQyUzQiU3QiUyMl8ldTAxNTdfXyV1MjAxRCV1MjUzQyU3RCUyMiV1MDM5RiUwOSV1MDNDOCVBNiV1MjEyRSVCMyV1MjAxOCV1MjUzQyU3RE8_)
```
...‚Äò               push "BS   "                                            ["BS   "]
    9Œî             push an array of numbers up to 9                        ["BS   ", [1,2,3,4,5,6,7,8,9]]
      √∏‚àë           join into a single string (without √∏ it results to 45)  ["BS   ", "123456789"]
        "`≈ó0-=‚Äù    push "`≈ó0-=" with ≈ó replaced with the digits            ["BS   ", "`1234567890-="]
               ƒç   chop that into an array of characters                   ["BS   ", ["`","1","2","3","4","5","6","7","8","9","0","-","="]]
                Œö  add the first "BS   " to the end of the array           [["BS   ","`","1","2","3","4","5","6","7","8","9","0","-","="]]
"TAB  ‚Äù            push "TAB  "                  [[..], "TAB  "]
       Q..P[]\‚Äù    push "QWERTYUIOP[]\"          [[..], "TAB  ", "QWERTYUIOP[]\"]
               ƒç   chop that                     [[..], "TAB  ", ["Q","W","E","R","T","Y","U","I","O","P","[","]","\"]]
                +  prepend to the array "TAB  "  [[..], ["TAB  ","Q","W","E","R","T","Y","U","I","O","P","[","]","\"]]
"...‚Äò             push "caps  "                       [.. , "caps  "]
     ‚Å∑Œü‚Äò          push "enter"                        [.. , "caps  ", "enter"]
        AL;'‚Äù     push "ASDFGHJKL;'"                  [.. , "caps  ", "enter", "ASDFGHJKL;'"]
             ƒç    chop that                           [.. , "caps  ", "enter", ["A","S","D","F","G","H","J","K","L",";","'"]]
              Œö   append "enter" to the end of array  [.. , "caps  ", ["A","S","D","F","G","H","J","K","L",";","'","enter"]]
               +  prepend "caps  " to the array       [.. , ["caps  ","A","S","D","F","G","H","J","K","L",";","'","enter"]]
"..‚Äò             push "shift   "                [..., "shift   "]
    ZM,./‚Äù       push "ZXCVBNM,./"              [..., "shift   ", "ZXCVBNM,./"]
          ƒç      chop it                        [..., "shift   ", ["Z","X","C","V","B","N","M",",",".","/"]]
           ‚Å¥     duplicate the shift            [..., "shift   ", ["Z","X","C","V","B","N","M",",",".","/"], "shift   "]
            ++   append and prepend the shifts  [..., ["shift   ","Z","X","C","V","B","N","M",",",".","/","shift   "]]
              ¬π  get all the arrays into one big array
result: [[["BS   ","`","1","2","3","4","5","6","7","8","9","0","-","="], ["TAB  ","Q","W","E","R","T","Y","U","I","O","P","[","]","\"], ["caps  ","A","S","D","F","G","H","J","K","L",";","'","enter"], ["shift   ","Z","X","C","V","B","N","M",",",".","/","shift   "]]]
 - a 2D array of the keyboard characters
{                                    for each array in the array do
 "...‚Äò                                 push " |||"
      ƒç                                chop to chars
       ;                               get the main array ontop
        {                        }     for each string in the array
         U                               uppercase it (before lowercase was used for better compression)
          ;                              get the chopped array ontop
           "_||/‚Äù                        push "_||/"
                 ‚îº                       append vertically
                  ;                      get the string ontop
                   {       }             for each char in the string do
                    "_≈ó__‚Äù                 push "_≈ó__"
                          ‚îº                append vertically
                            "..‚Äò         push "    _||\ |||"
                                ‚îº        append vertically-then horizontally
                                  O    output that in a newline
```
[Answer]
# Swift, 777 Bytes
```
func b(_ c:String,_ d:Int,_ e:Int)->[String]{var f=Array(" __ |||||||||/\\|".characters),g=[String]()
for h in 0..<4{var i="";for j in e..<4{i.append(f[j+h*4])
if j==1{var k="_",l=0;if h==1{k=" ";l=c.characters.count;i += c}
for _ in l..<d{i+=k}}};g.append(i)};return g}
func c(_ d:String)->[(String,Int)]{return Array(d.characters).map{("\($0)",2)}}
func d(_ e:String,_ f:Int)->[(String,Int)]{return [(e,f)]}
var e=[c("`1234567890-=")+d("BS",6),d("TAB",6)+c("QWERTYUIOP[]\\")]
e+=[d("CAPS",7)+c("ASDFGHJKL;'")+d("ENTER",6),d("SHIFT",9)+c("ZXCVBNM,./")+d("SHIFT",9)]
var f="";for g in 0..<e.count{let h=e[g]
var i=[[String]]();for j in 0..<h.count{
let k=h[j],l=b(k.0,k.1,(j>0 ? 1:0));i.append(l)}
for k in 0..<4{if g>0||k>0{f+="\n"}
for l in i{f+=l[k]}}};print(f,separator:"")
```
Swift is generally not a great language of choice for golfing, so being less than double the current smallest answer (that was fast) ~~is a good challenge here!~~
Ungolfed:
```
func createKeyboard() {
    func createKey(_ text: String, _ middleWidth: Int, _ startingColumn: Int) -> [String] {
        var keyTempalte = " __ |||||||||/\\|"
        var keyTemplateCharacters = Array(keyTempalte.characters)
        var output = [String]()
        for y in 0 ..< 4 {
            var line = ""
            for x in startingColumn ..< 4 {
                line.append(keyTemplateCharacters[x + y*4])
                if x == 1 {
                    var spacingCharacter = "_"
                    var startingOffset = 0
                    if y == 1 {
                        spacingCharacter = " "
                        startingOffset = text.characters.count
                        line += text
                    }
                    for _ in startingOffset ..< middleWidth {
                        line += spacingCharacter
                    }
                }
            }
            output.append(line)
        }
        return output
    }
    func stringToCharacterStrings(_ str: String) -> [(String, Int)] {
        return Array(str.characters).map {("\($0)",2)}
    }
    func specialKey(_ str: String, _ middleWidth: Int) -> [(String, Int)] {
        return [(str, middleWidth)]
    }
    var keys = [stringToCharacterStrings("`1234567890-=") + specialKey("BS", 6),
                specialKey("TAB", 6) + stringToCharacterStrings("QWERTYUIOP[]\\")]
    keys += [specialKey("CAPS", 7) + stringToCharacterStrings("ASDFGHJKL;'") + specialKey("ENTER", 6),
                specialKey("SHIFT", 9) + stringToCharacterStrings("ZXCVBNM,./") + specialKey("SHIFT", 9)]
    var output = ""
    for r in 0 ..< keys.count {
        let row = keys[r]
        var rowKeys = [[String]]()
        for i in 0 ..< row.count {
            let elem = row[i]
            let key = createKey(elem.0, elem.1, (i>0 ? 1 : 0))
            rowKeys.append(key)
        }
        for y in 0 ..< 4 {
            if r > 0 || y > 0 {
                output += "\n"
            }
            for key in rowKeys {
                output += key[y]
            }
        }
    }
    print(output)
}
createKeyboard()
```
[Answer]
# Python 2, ~~394~~ ~~388~~ 380 bytes
```
k=[4]*13+[8],[8]+[4]*13,[9]+[4]*11+[8],[11]+[4]*10+[11];m='`1234567890-=*','*QWERTYUIOP[]*',"*ASDFGHJKL;'*",'*ZXCVBNM,./*';c,d,e,n,u=0,'','|','\n','_'
for a in 0,1,2,3:
 f=s=t=o='';x=0
 for y in k[a]:g=y-2;f+=' '+u*y;s+=e*2+m[a][x].replace('*','%s')+' |';t+=e*2+u*g+e;o+='|/'+u*g+'\\';x+=1
 d+=f+n+s+e+n+t+e+n+o+e+n
l='SHIFT   ';print d%('BS   ','TAB  ','\\','CAPS  ','ENTER',l,l)
```
Just builds a big string representing the whole keyboard, replaces \* with %s for the special keys then uses string formatting to update the specials.
**Edit**
Now has a trailing newline at the end of the output but I don't see anywhere that's not allowed.
[Try it online!](https://tio.run/##LY7bboJAEIbveYqNiRm7OyqgbdXNXKjVag/WCj0iaY2iNSIYwUQS350u6MX8M9/MP7uzS@K/MDDTdENO3eVGTTgNF1WIM6LTvJTGeWIYF9ZFVsstwa9h1urXN7eNpl4mDgj89aM3sb/ehi9jx1WNAm9bd/37wcPjkwReUIbvz@57Z/SMlSoHOccFehjggXQEtX5SMQ2U/IC2DPdsxtYB09FAE2stjS0pophCApBH0hUrS5JZNs7Mba0oKZtyKQgYiANPZCTI46bYqqFzdCt7b@fP5l4JskOLEVwJYCeQ8dl14CvhyVBtn6qQE0yn6h9BhsYWgpYiEJHwlMa5hplqPoE1GPZtxhjI3X4dxGxRLEHHyhoIdruTZ/USQrc9tnLqjezeBNBH/ypN/wE "Python 2 ‚Äì Try It Online")
[Answer]
# C#, 376 bytes (when in one line)
---
```
var s="";foreach(var r in@"`|1|2|3|4|5|6|7|8|9|0|-|=|BS   ~TAB  |Q|W|E|R|T|Y|U|I|O|P|[|]|\~CAPS  |A|S|D|F|G|H|J|K|L|;|'|ENTER~SHIFT   |Z|X|C|V|B|N|M|,|.|/|SHIFT   ".Split('~'))for(int i=0,l;i<4;i++){foreach(var k in r.Split('|')){l=k.Length+1;var u=new string('_',l);s+=i<1?" "+u+"__":i<2?"||"+k.PadRight(l)+"|":i<3?"||"+u+"|":"|/"+u+@"\";}s+=i>0?"|\n":"\n";}Console.Write(s);
```
This is based entirely on Klinger's C# answer. I don't have enough rep to comment on his answer, otherwise I would.
I was able to slim down Klinger's code by 5 bytes, by modifying the initial foreach loop, and removing extraneous brackets.
```
var s="";
foreach(var r in@"`|1|2|3|4|5|6|7|8|9|0|-|=|BS   ~TAB  |Q|W|E|R|T|Y|U|I|O|P|[|]|\~CAPS  |A|S|D|F|G|H|J|K|L|;|'|ENTER~SHIFT   |Z|X|C|V|B|N|M|,|.|/|SHIFT   ".Split('~'))
for(int i=0,l;i<4;i++)
{
foreach(var k in r.Split('|'))
{
l=k.Length+1;
var u=new string('_',l);
s+=i<1?" "+u+"__"
:i<2
?"||"+k.PadRight(l)+"|"
:i<3
?"||"+u+"|"
:"|/"+u+@"\";
}
s+=i>0?"|\n":"\n";
}
Console.Write(s);
```
[Answer]
# m4, 456
```
changequote({,})define(d,{define($@)})d(p,{patsubst($@)})d(a,{{_}p({$1},.,_)_ })d(b,{|$1||})d(c,{|p({$1},.,_)||})d(e,{/p({$1},.,_)\|})d(f,{ifelse(len({$2}),0,,{indir({$1},{$2})f({$1},shift(shift($@)))})})d(g,{ f({a},$@)
|f({b},$@)
|f({c},$@)
|f({e},$@)
})g(` ,1 ,2 ,3 ,4 ,5 ,6 ,7 ,8 ,9 ,0 ,- ,= ,BS    )g(TAB   ,Q ,W ,E ,R ,T ,Y ,U ,I ,O ,P ,[ ,] ,\ )g(CAPS   ,A ,S ,D ,F ,G ,H ,J ,K ,L ,; ,' ,ENTER )g(SHIFT    ,Z ,X ,C ,V ,B ,N ,M ,{,} ,. ,/ ,SHIFT    )
```
Ungolfed:
```
changequote({,})dnl
define(key1, {{_}patsubst({$1}, ., _)_ })dnl _______ 
define(key2, {|$1||})dnl                     |TAB  ||
define(key3, {|patsubst({$1}, ., _)||})dnl   |_____||
define(key4, {/patsubst({$1}, ., _)\|})dnl   /_____\|
define(rkey, {dnl
ifelse(dnl
len({$2}), 0, ,dnl terminate on empty argument
{dnl
indir({$1}, {$2})dnl
rkey({$1}, shift(shift($@)))dnl
}dnl
)dnl
})dnl
define(row, {dnl
 rkey({key1}, $@)
|rkey({key2}, $@)
|rkey({key3}, $@)
|rkey({key4}, $@)dnl
})dnl
row(` ,1 ,2 ,3 ,4 ,5 ,6 ,7 ,8 ,9 ,0 ,- ,= ,BS    )
row(TAB   ,Q ,W ,E ,R ,T ,Y ,U ,I ,O ,P ,[ ,] ,\ )
row(CAPS   ,A ,S ,D ,F ,G ,H ,J ,K ,L ,; ,' ,ENTER )
row(SHIFT    ,Z ,X ,C ,V ,B ,N ,M ,{,} ,. ,/ ,SHIFT    )
```
(This is actually the first time I'm both code-golfing and giving m4 a try.)
[Answer]
# [stacked](https://github.com/ConorOBrien-Foxx/stacked), 228 bytes
[Try it here!](http://conorobrien-foxx.github.io/stacked/stacked.html)
```
[,{a:a size@n(' __' '_'n 1+:@k*LF'||'a' ' '|'LF'||' '_'k*:@o'|'LF'|/'o'\')sum}"!$hcat#/!' |||'hcat out]@:p$chars@:c'`1234567890-='c'BS   'p'TAB  ' 'QWERTYUIOP[]\'c p'CAPS  ' 'ASDFGHJKL;'''c,'ENTER'p'SHIFT   ':@q'ZXCVBNM,./'c,q p
```
Or, slightly more readable:
```
{a:a size@n(' __' '_'n 1+:@k*LF'||'a' ' '|'LF'||' '_'k*'|'LF'|/' '_'k*'\')sum}"@:m
[,m$hcat#/!' |||'hcat out]@:p
'`1234567890-='chars'BS   'p
'TAB  ' 'QWERTYUIOP[]\'chars p
'CAPS  ' 'ASDFGHJKL;'''chars,'ENTER'p
'SHIFT   ':@q'ZXCVBNM,./'chars,q p
```
This works by defining a function `p` that makes a key, then `hcat`ing multiple keys.
[Answer]
# Haskell, 255
```
import Data.List;a#b=a++[b];e=" |||";s=map(:" ");k x=[e,"_||/"]++['_':c:"__"|c<-x]#"_||\\";t="SHIFT    ";main=mapM_ putStrLn$transpose.(#e).(k=<<)=<<[s"`1234567890-="#"BS    ","TAB   ":s"QWERTYUIOP[]\\","CAPS   ":s"ASDFGHJKL;'"#"ENTER ",t:s"ZXCVBNM,./"#t]
```
In retrospect, similar in concept to [this Haskell answer](https://codegolf.stackexchange.com/a/103120/40), but producing the ASCII keyboard, and with slightly different golfing.
Formatted and renamed:
```
import Data.List
main :: IO ()
main = mapM_ putStrLn
  $ concatMap (transpose . (`append` end) . concatMap key)
  [ split "`1234567890-=" `append` "BS    "
  , "TAB   " : split "QWERTYUIOP[]\\"
  , "CAPS   " : split "ASDFGHJKL;'" `append` "ENTER "
  , shift : split "ZXCVBNM,./" `append` shift
  ]
key :: String -> [String]
key x
  = [end, "_||/"]
  ++ ['_' : c : "__" | c <- x]
  `append` "_||\\"
append :: [a] -> a -> [a]
append a b = a ++ [b]
split :: [Char] -> [String]
split = map (: " ")
end :: String
end = " |||"
shift :: String
shift = "SHIFT    "
```
[Answer]
# tcl, 368
As counted by <http://textmechanic.com/text-tools/basic-text-tools/count-characters-words-lines/> with the "Count line breaks as spaces." set to on, it occupies ~~505~~ ~~496~~ ~~452~~ ~~451~~ ~~439~~ ~~403~~ ~~401~~ ~~396~~ ~~391~~ ~~388~~ ~~385~~ ~~384~~ ~~382~~ ~~379~~ ~~378~~ ~~377~~ ~~369~~ **368**
```
proc N x {split $x @}
proc M a\ b {string map $a $b}
regsub -all \[^@|] [set b [M [N {||||@|||@$@BS   @%@TAB  @&@CAPS @? @ENTER  @*@SHIFT   }] [regsub -all {[^@]} "`1234567890-=$@%QWERTYUIOP\[\]\\@&ASDFGHJKL;'?@*ZXCVBNM,./*" {||& ||}]]] _ f
lmap x [N [M {\\ _ / _ | \ } [set g [M {||_ |/_ _|| _\\|} [M {||| \\|/} $f]]]]] y [N $b] z [N $f] w [N $g] {puts "$x
$y
$z
$w"}
```
Demo: <http://rextester.com/live/NTVAV88033>
The ungolf:
Live cooperation on <http://rextester.com/live/UDO43692>
```
regsub -all {(\S)} "`1234567890-=‚Üê\n%QWERTYUIOP\[\]\\\n‚á©ASDFGHJKL;'‚Üµ\n‚áßZXCVBNM,./‚áß" {||\1 ||} b
set b [string map {|||| |||  ‚Üê "BS   " % "TAB  " ‚á© "CAPS  " ‚Üµ "ENTER" ‚áß "SHIFT   "} $b]
regsub -all {[^\n|]} $b _ f
set g [string map {||| \\|/} $f]
set g [string map {||_ |/_  _|| _\\|} $g]
set h [string map {\\ _ / _ | " "} $g]
set H [split $h \n]
set B [split $b \n]
set F [split $f \n]
set G [split $g \n]
lmap x $H y $B z $F w $G {
puts $x
puts $y
puts $z
puts $w
}
```
Anyone is free and welcome to improve my version on live cooperation sites, but please: do not edit my original answer here; just say you've edited in the comments and people will visit the links.
**UPDATE 1:** Replaced `for` by `foreach`, because latter produces shorter code
**UPDATE 2:** Replaced `foreach` by `lmap`, because latter produces shorter code
**UPDATE 3:** Shaved one char because I Replaced `" "` by `\` 
**UPDATE 4:** In respect to first comment, I changed all the 1st line 2 byte Unicode place holder characters to 1 byte ASCII ones
**UPDATE 5:** multiple `puts` line made into only one
**UPDATE 6:** use directly `split` commands return values on the `lmap` call instead of using intermediate list variables
**UPDATE 7:** Quotes around `ENTER` were not needed
**UPDATE 8:** `string map` is long enough and repeated a number of times that it is worth to encapsulate it in a `proc`
**UPDATE 9:** `split $x \n` is long enough and repeated a number of times that it is worth to encapsulate it in a `proc`
**UPDATE 10:** On "replacement" string can use `&` instead of `\1`, because in this case both coincide; another consequence of this is it allows to get rid of `()`on the "matching" string.
**UPDATE 11:** Use `@` instead of `\n`as line separator for further use on `split` instructions. Although the "match" string lengthens from `\S` to `[^@]` it pays off , due to number of repetitions
**UPDATE 12:** Replaced the first `regsub` "match" string `{[^@|]}` by`\[^@|]` to shave one character off. Unfortunately, could not do the same to the second `regsub`, because the instruction is inside a pair of `[]` :(
**UPDATE 13:** Shaved two Enter characters by concentrating the `lmap` body with its own heading.
**UPDATE 14:** Used a call to the `split` based procedure `N` instead of a direct call to the `string map` based procedure `N` which allows to shorten by 3 characters
**UPDATE 15:** There was an unneeded  space character. Removed it to shave one char off.
**UPDATE 16:** `set h` can be embedded to get rid of `$h`, to shave one character off.
**UPDATE 17:** `set h` statement can really be shaved off.
**UPDATE 18:** `puts` argument changed from the `...\n...\n...\n...` format to the
```
"...
...
...
..." 
```
format.
Thanks to people that helped me to shorten it, especially evilotto and aspect of the tcl IRC channel!
[Answer]
## tcl, 369
Initially based in tcl's sergiol version.  
(Note that many left spaces are part of tcl's "nature")
```
lmap z {S R M} w {set "regsub -all" "string map"} {interp alias {} $z {} {*}$w};lmap x {"`1234567890-=¬øBS   ¬ø" "¬øTAB  ¬øQWERTYUIOP\[\]\\" "¬øCAPS  ¬øASDFGHJKL;'¬øENTER¬ø" "¬øSHIFT   ¬øZXCVBNM,./¬øSHIFT   ¬ø"} {S h [M {\\ _ / _ | \ } [S g [M {||_ |/_  _|| _\\|} [M {||| \\|/} [S f [R {[^\n|]} [S b [M {|||| |||} [R {¬ø(\S+\s*)¬ø|(.)} $x {||\1\2 ||}]]] _ ]]]]]];puts $h\n$b\n$f\n$g}
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~378~~ ~~342~~ ~~330~~ 327 bytes
-10 -3 bytes thanks to ceilingcat.
A first stab at it. The repeated g()'s suggests room for improvement.
Edit: There we go.
```
char*k[]={"eZXCVBNM,./e","cASDFGHJKL;'d","bQWERTYUIOP[]\\","`1234567890-=a","BS","TAB","CAPS","ENTER","SHIFT"},*s;f(w,i,j){for(i=16;i--;puts(""))for(s=k[i/4],j=i%4;*s;printf("%s%s%-*.*s%.2s",L" |"+(s++-k[i/4]?2:j<3),L"/||"+j,w,i&2?j^3?w>2?w:1:w+2:w,j^2?"___________":w>2?k[*s-93]:s,"\\||||| "+j*2))w=*s>96?"FFGFI"[*s-97]-64:2;}
```
[Try it online!](https://tio.run/##RU/bTsJAEP0VMgm62@6CbGuR1tIAUkBREeq1LYoVdEtEwmL6AHw7TvXBmWQmc86cuST8PUn2@@RjstLmYexuYPr00LprXl2yUnkKDJLG6MzvdM8v@s7hG9avN/ftYfB427sehHEUIfJSEYZ5bFVPakfcnSDQHGEIGk2MrcYgL9pXQXuIedTt@QHsmKacGcmYZCndzL5WRLoVy5GcO8vvtSIAlOaocuehLJsxS11ZNB0ULVdysZ4RKCp0rpU0VSwJBawPhS3oROk6/5N4wk5PDYpEeYtMynDZgfDSseFldeFldsXOdGFnLB0LD57/Deycn4ea4jUjthWDKNrmVsApmqA0czVVr1ke@H7H78FvYzXmlmkLZ7fH8wqfE7kg@BehCPwA "C (gcc) ‚Äì Try It Online")
[Answer]
# Python 2, 672 bytes
Using a compressed zlib string:
```
print 'x\x9c\xad\xd3\xb9\x0e\x82@\x10\x80\xe1\x9e\xa7\xa0\xb3\xf1\xbe\x8d\xb1\x00\xbc\x0f<\xc0\x1b\xb3>\xc8<\xbc\xfc\x8bf\x8d\xed8\xc5\x17\x9a\xddd\xfe,\xbe\xc9\xc7\xd7b?<\x91\xa7/"\rhB\x0b\xda\xd0\x81.\xf4\xa0\x0f\x03\xa8C\x05F\x10&~>"\xf9]\xc6\x88\x16\x86\xbbj\xc6dZ\x98L<\xb7\xae\x9a|\xc74\x08\xed\xba\xb2\x873L\xe0\x00)\\\xe1\x08\x0b\xd8\xc2\x0e\xee\xf0\x80\xec\xd3\xabXW\x1d\xces\xeb\xaa\xc3\xb9^\x7fy_Q\xb0K\x8a`\x01$0\x86)\xcc`\x0eKX\xc1\x1a\x86P\xb2u\xe3tr\xf8\xee\xf5\xaf\xf7\xa5\x0e\xf6\xfb\xbet\xb1\xde\xbd\x92\xf9b\x9a\x16\x7f\x94\xdc\xe0\x02\x11\x9c\xec\xef\x061l\xa0\x0cU\xa8\xd9\xbc\xee\xb4\xeb\xa5\x8a\xf5\xd3K\x15\xcb\x9e~\x01r\xfc\xb9\xee'.decode('zlib')
```
[Answer]
## Mathematica 323 bytes
```
Uncompress@"1:eJyt00luwjAUgGE2vUdYsWGeEeoiUGYIEKcTTWXEBXqBd3jy26CUYWe/xads8iT/sounv1gFL4VCoLNxxnyk9UZT5BiISAOa0II2dKALPejDAOpQgVcYqSAbEbtOa3GFuayraZ2mPmWyL5bnIZyxR0/CkQkhe/iECcSQwDe8wwK2sIMf+IV/IW0H56LXkJej+016E9LXlRyHO2VLhqDgDaYwgzksYQVrGELJZI+SSXxX0uOV9Jry2Y10q5iHVPPFNLGvUw7wBWP4ME8XIthAGapQM93zv29COlV8DOkrol10BmvF28U="
```
Boring and uncreative. The string is just the output of the built-in `Compress` command applied to the desired output.
[Answer]
# Powershell, ~~249~~ 242 bytes
```
"``1234567890-=Bs   
Tab  QWERTYUIOP[]\
Caps  ASDFGHJKL;'Enter
Shift   ZXCVBNM,./Shift   "-split'
'|%{($u=($r=,''+($_-csplit'(.[a-z ]*)'-ne''|% t*per)+'')-replace'.','_')-join'__ _'
$r-join' |||'
$u-join'_|||'
$u-join'_\|/'}|%{-join$_[2..76]}
```
## Ungolfed & Explained
The middot `¬∑` uses instead spaces to to clarify the source string.
```
"``1234567890-=Bs¬∑¬∑¬∑
Tab¬∑¬∑QWERTYUIOP[]\
Caps¬∑¬∑ASDFGHJKL;'Enter
Shift¬∑¬∑¬∑ZXCVBNM,./Shift¬∑¬∑¬∑"-split"`n"|%{        # split the string with rows by new line
$r=,''+($_-csplit'(.[a-z ]*)'-ne''|% t*per)+''  # split each row by key labels (any char plus small letters or spaces), 't*per' is shortcut for toUpper method
$u=$r-replace'.','_'                            # replace any char to _ to take an upper 
$u-join'__ _'                                   # join labels and push 4 strings to pipe
$r-join' |||'
$u-join'_|||'
$u-join'_\|/'
}|%{
    -join$_[2..76]                              # return substring for each string
}
# $r =
# ["","`","1","2","3","4","5","6","7","8","9","0","-","=","BS   ",""]
# ["","TAB  ","Q","W","E","R","T","Y","U","I","O","P","[","]","\",""]
# ["","CAPS  ","A","S","D","F","G","H","J","K","L",";","'","ENTER",""]
# ["","SHIFT   ","Z","X","C","V","B","N","M",",",".","/","SHIFT   ",""]
# $u =
# ["","_","_","_","_","_","_","_","_","_","_","_","_","_","_____",""]
# ["","_____","_","_","_","_","_","_","_","_","_","_","_","_","_",""]
# ["","______","_","_","_","_","_","_","_","_","_","_","_","_____",""]
# ["","________","_","_","_","_","_","_","_","_","_","_","________",""]
# before substring:
# __ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ________ _
#  |||` |||1 |||2 |||3 |||4 |||5 |||6 |||7 |||8 |||9 |||0 |||- |||= |||BS    |||
# _|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||______|||
# _\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/______\|/
# __ ________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ _
#  |||TAB   |||Q |||W |||E |||R |||T |||Y |||U |||I |||O |||P |||[ |||] |||\ |||
# _|||______|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||
# _\|/______\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/
# __ _________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ________ _
#  |||CAPS   |||A |||S |||D |||F |||G |||H |||J |||K |||L |||; |||' |||ENTER |||
# _|||_______|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||______|||
# _\|/_______\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/______\|/
# __ ___________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ___________ _
#  |||SHIFT    |||Z |||X |||C |||V |||B |||N |||M |||, |||. |||/ |||SHIFT    |||
# _|||_________|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||_________|||
# _\|/_________\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/_________\|/
# final output:
#  ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ________
# ||` |||1 |||2 |||3 |||4 |||5 |||6 |||7 |||8 |||9 |||0 |||- |||= |||BS    ||
# ||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||______||
# |/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/______\|
#  ________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____
# ||TAB   |||Q |||W |||E |||R |||T |||Y |||U |||I |||O |||P |||[ |||] |||\ ||
# ||______|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__||
# |/______\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|
#  _________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ________
# ||CAPS   |||A |||S |||D |||F |||G |||H |||J |||K |||L |||; |||' |||ENTER ||
# ||_______|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||______||
# |/_______\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/______\|
#  ___________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ___________
# ||SHIFT    |||Z |||X |||C |||V |||B |||N |||M |||, |||. |||/ |||SHIFT    ||
# ||_________|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||_________||
# |/_________\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/_________\|
```
---
## Extra: keyboard with a space bar & right aligned labels, 278 bytes
I've added a couple of bytes to the regular expression to handle the space bar (old regexp `(.[a-z ]*)`, new one `~|(.[a-z ]*)`). That's one small step for the regexp, one giant leap for the solution: you can now display space bar and key labels aligned to the right (see SHIFT, CTRL and BS on the right side of the keyboard).
```
"``1234567890-=~   bs
Tab  QWERTYUIOP[]\
Caps  ASDFGHJKL;'Enter
Shift   ZXCVBNM,./~   shift
Ctrl  Alt ~$(' '*34)Alt ~  ctrl"-split'
'|%{($u=($r=,''+($_-csplit'~|(.[a-z ]*)'-ne''|% t*per)+'')-replace'.','_')-join'__ _'
$r-join' |||'
$u-join'_|||'
$u-join'_\|/'}|%{-join$_[2..76]}
```
Output:
```
 ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ________
||` |||1 |||2 |||3 |||4 |||5 |||6 |||7 |||8 |||9 |||0 |||- |||= |||   BS ||
||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||______||
|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/______\|
 ________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____
||TAB   |||Q |||W |||E |||R |||T |||Y |||U |||I |||O |||P |||[ |||] |||\ ||
||______|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__||
|/______\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|
 _________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ________
||CAPS   |||A |||S |||D |||F |||G |||H |||J |||K |||L |||; |||' |||ENTER ||
||_______|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||______||
|/_______\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/______\|
 ___________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ___________
||SHIFT    |||Z |||X |||C |||V |||B |||N |||M |||, |||. |||/ |||   SHIFT ||
||_________|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||_________||
|/_________\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/_________\|
 _________ _______ _____________________________________ _______ _________
||CTRL   |||ALT  |||                                   |||ALT  |||  CTRL ||
||_______|||_____|||___________________________________|||_____|||_______||
|/_______\|/_____\|/___________________________________\|/_____\|/_______\|
```
[Answer]
# [///](https://esolangs.org/wiki////), 360 bytes
```
/f/!!//e/SHIFT   //d/\/\///c/ "db/ 
\|\|da/\\\|d@/#####d?/__d>/?\\\\a
c"d</aa
ad:/fffff!d&/ccccd%/ aaad#/?aaa?aaad"/??d!/?\\\\a\\\d&&&cc"b`%1%2%3%4%5%6%7%8%9%0%-%=%BS    <|@#?|||"?<\/:f">&&&cbTAB  %Q%W%E%R%T%Y%U%I%O%P%[%]%\\ <|"@#?|||?<\/":f>_&&&"bCAPS  %A%S%D%F%G%H%J%K%L%;%'%ENTER <|"_@#"?<\/"_:!">?_&&ccc"?_be%Z%X%C%V%B%N%M%,%.%\/%e <|""_|||@""_<\/"?_:""_\a
```
[Try it online!](https://tio.run/##LY5JT8NADIXv/RUTRy9cALMvoWTSlZallDbsg4ZJnIgDt17z38MM8CzrWZY@P2@@3ear3nQdNxxFzDWvZ/NpoZRiFja@mCtWJCWrnmlNK46N8ZZzHCSarZWMtV8a16tI@uxcz0nKTVAkCVdeAlbOOYlZewstxFpL9E/6liRJqorKT@zjAIc4wjFOcIoznGMPO7jEcO3/Uv02j3XbtqT7htOGssCVxWCoFB7wjAlWKPCKR8xxjyXe8QFjPEZ/XMAobTLrOSpHg6W/igHWGGOKK8xwjRvc4gJbmCyKySqQNo9/48imEWXahk8r0ras8YYXjPCEIRa4wzZ2YRh1gMj6tNxbALVN/WRc1/0A "/// ‚Äì Try It Online")
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 293 bytes
```
c=##&@@(#|2&/@Characters@#)&
r=StringRiffle
p=StringPadRight
Print/@{j=p["",#2,"_"]&@@@#;(" __"<>#&/@j)<>" ",r[p@@@#,i={l="||","|||",l}],j~r~i,j~r~{"|/","\|/","\|"}}&/@{{c@"`1234567890-=","BS"|6},{"TAB"|6,c@"QWERTYUIOP[]\\"},{"CAPS"|7,c@"ASDFGHJKL;'","ENTER"|6},{h="SHIFT"|9,c@"ZXCVBNM,./",h}}
```
[Try it online!](https://tio.run/##LY5dT4NAEEXf@RXNbIJtsoqitjbtNkuR2vpREfATCBKkBUINQd5Y@tdx0L6czOTcuZldWCXxLqzSKGzbiBEic94nQpUVridhGUZVXP5wMpClktlVmX5vrXSzyWOpOKxm@GWl26SSTNwqhdcZK1wASlQKAfhYx8mkD70ggOmMYG02mM6gB7R0i87RlNU5AyGAIpB549NsX@7TP9YgFDTegdA0WFHXEYfPM/X84nI4uhqfHjOUcxvEsKE1ONocJ4qRp1fDct6fV4@m63sedFLXTMyNOqvZ14ub5e3d/eQIz421Y1j/DQkDe7laOCDGXe7jTX@Zrx/oCb6QNE3b/gI "Wolfram Language (Mathematica) ‚Äì Try It Online")
Relatively straightforward: encodes rows of keys as lists of `*(key name)*|*(key width)*`
```
c=##&@@(#|2&/@Characters@#)&    (*converts a string into (key)|2 s*)
r=StringRiffle
p=StringPadRight
 Print/@
  {j=p["",#2,"_"]&@@@#;
   (" __"<>#&/@j)<>" ",         (*top of the keys*)
   r[p@@@#,i={l="||","|||",l}], (*key names*)
   j~r~i,                       (*space under key names*)
   j~r~{"|/","\|/","\|"}            (*bottom of the keys*)
  }
 &/@
{
 {c@"`1234567890-=","BS"|6},
 {"TAB"|6,c@"QWERTYUIOP[]\\"},
 {"CAPS"|7,c@"ASDFGHJKL;'","ENTER"|6},
 {h="SHIFT"|9,c@"ZXCVBNM,./",h}
}
```
[Answer]
# [Perl 5](https://www.perl.org/) `-MList::Util=pairmap`, 313 bytes
```
pairmap{$_=$b;s/\|{3}/|-|/g;y/-/_/c;y/-/ /;s/./ /;chop;say;$_=$b;for$r($a=~/./g){s/\| /|$r/}say;y/|/_/c;say;s,\|_,/_,g;s/_\|/_\\/g;say}"`1234567890-=",($;="||  |")x13 ."||BS    ||","QWERTYUIOP[]\\",'||TAB   |'.$;x13 .'|',"ASDFGHJKL;'","||CAPS   |".$;x11 ."||ENTER ||","ZXCVBNM,./",($s='||SHIFT    |').$;x10 ."$s|"
```
[Try it online!](https://tio.run/##LZBdT4MwFIb/CmmasCWFgogfa7hgk7npNudgftYgLjpJNiF0F5Id/Oli29mbtyfveZ9zcsr3auO3bZnl1TYr9zgN8BsTlMPeayhYQNesphZN6UqrQaVpK1l9FiUTWc0OkY@iwlUHZ8GPtNfdvUIYFHBFG9VUU9AM9ReEQ0poStaSlXJpcC7HSKtBr@6Rd@yfnJ6dO1aASAezAAEYBqDut@sZtiz6sSEfACLo9j5aJI/L8c38@YVzREyAJOwr17Qx0wETTILC@GJ4Obq6njBTpgAG4VxBAOkuV2OjWRItDtinh8FdfzYlNlUbiEBi49F4mOi5ZleHHBnCAlDb/hblLi@@RGtNfdtxHamTXOx6veUu3wT/h/0D "Perl 5 ‚Äì Try It Online")
]