Write language name in 3D ASCII: Difference between revisions

From Rosetta Code
Content added Content deleted
m (added whitespace before the TOC (table of contents), added a ;Task: (bold) header.)
 
(71 intermediate revisions by 40 users not shown)
Line 4: Line 4:


;Task:
;Task:
The task is to write the language's name in 3D ASCII.
Write/display a language's name in '''3D''' ASCII.



(We can leave the definition of "3D ASCII" fuzzy,
(We can leave the definition of "3D ASCII" fuzzy,
so long as the result is interesting or amusing,
so long as the result is interesting or amusing,
not a cheap hack to satisfy the task.)
not a cheap hack to satisfy the task.)


;Related tasks:
* [[Draw_a_sphere|draw a sphere]]
* [[Draw_a_cuboid|draw a cuboid]]
* [[Draw_a_rotating_cube|draw a rotating cube]]
* [[Death_Star|draw a Deathstar]]
<br><br>
<br><br>

=={{header|11l}}==
<syntaxhighlight lang="11l">V s =
|‘ XX
X
X
X
X
X
XXXXX’

V lines = s.split("\n")
V width = max(lines.map(l -> l.len))

L(line) lines
print((‘ ’ * (lines.len - L.index - 1))‘’(line.ljust(width).replace(‘ ’, ‘ ’).replace(‘X’, ‘__/’) * 3))</syntaxhighlight>

{{out}}
<pre>
__/__/ __/__/ __/__/
__/ __/ __/
__/ __/ __/
__/ __/ __/
__/ __/ __/
__/ __/ __/
__/__/__/__/__/ __/__/__/__/__/ __/__/__/__/__/
</pre>


=={{header|360 Assembly}}==
=={{header|360 Assembly}}==
3D EBCDIC. This program does nothing clever in any way: it just prints out strings.
3D EBCDIC. This program does nothing clever in any way: it just prints out strings.
<lang 360asm>THREED CSECT
<syntaxhighlight lang="360asm">THREED CSECT
STM 14,12,12(13)
STM 14,12,12(13)
BALR 12,0
BALR 12,0
Line 25: Line 60:
BR 14
BR 14
LTORG
LTORG
END</lang>
END</syntaxhighlight>
{{out}}
{{out}}
<pre>
<pre>
Line 36: Line 71:


</pre>
</pre>

=={{header|Action!}}==
Atari 8-bit computers use [https://en.wikipedia.org/wiki/ATASCII ATASCII] character set which is a variation of ASCII.
<syntaxhighlight lang="action!">BYTE ARRAY data = [
$00 $00 $00 $00 $4E $4E $4E $00 $00 $00 $00 $00 $00 $00 $00 $00 $4E $00 $00 $00 $00 $4E $00 $00 $00 $00 $00 $00 $00 $00 $00 $00 $00 $00 $00 $00 $4E $00 $00 $00
$00 $00 $00 $46 $47 $00 $00 $47 $00 $00 $00 $00 $00 $00 $00 $42 $47 $47 $00 $00 $42 $47 $47 $00 $00 $00 $00 $00 $00 $00 $00 $00 $00 $00 $00 $42 $47 $47 $00 $00
$00 $00 $42 $47 $48 $80 $80 $80 $4A $00 $00 $4E $4E $4E $00 $42 $00 $80 $4E $00 $00 $47 $80 $00 $00 $4E $4E $00 $00 $00 $4E $4E $4E $00 $00 $42 $00 $80 $00 $00
$00 $00 $42 $00 $80 $00 $42 $00 $80 $00 $46 $47 $00 $00 $47 $42 $00 $80 $00 $47 $00 $4E $00 $00 $46 $47 $00 $47 $00 $42 $47 $00 $00 $47 $00 $42 $00 $80 $00 $00
$00 $00 $42 $00 $80 $00 $42 $00 $80 $42 $47 $48 $80 $80 $80 $42 $00 $80 $80 $80 $42 $47 $47 $42 $47 $48 $80 $80 $4A $42 $00 $80 $80 $80 $4A $42 $00 $80 $00 $00
$00 $00 $42 $00 $80 $4D $4D $47 $80 $42 $00 $80 $00 $00 $00 $42 $00 $80 $00 $00 $42 $00 $80 $42 $00 $80 $42 $00 $80 $42 $00 $80 $42 $00 $80 $42 $00 $80 $00 $00
$00 $00 $42 $00 $80 $80 $80 $80 $80 $42 $00 $80 $00 $00 $00 $42 $00 $80 $00 $00 $42 $00 $80 $42 $00 $80 $42 $00 $80 $42 $00 $80 $42 $00 $80 $00 $47 $80 $00 $00
$00 $00 $42 $00 $80 $00 $42 $00 $80 $42 $00 $80 $4E $4E $00 $42 $00 $80 $4E $00 $42 $00 $80 $42 $00 $80 $42 $00 $80 $42 $00 $80 $42 $00 $80 $00 $4E $00 $00 $00
$00 $00 $42 $00 $80 $00 $42 $00 $80 $00 $47 $80 $00 $00 $47 $00 $47 $80 $00 $47 $42 $00 $80 $00 $47 $80 $4D $47 $80 $42 $00 $80 $42 $00 $80 $42 $47 $47 $00 $00
$00 $00 $00 $47 $80 $00 $00 $47 $80 $00 $00 $CA $80 $80 $80 $00 $00 $CA $80 $80 $00 $47 $80 $00 $00 $CA $80 $80 $C8 $00 $47 $80 $00 $47 $80 $00 $47 $80 $00 $00]

PROC Main()
BYTE POINTER ptr

Graphics(0)
SetColor(2,0,2)
ptr=PeekC(88)+280
MoveBlock(ptr,data,400)
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Write_language_name_in_3D_ASCII.png Screenshot from Atari 8-bit computer]


=={{header|Ada}}==
=={{header|Ada}}==
Quotes are not escaped by \ in ada (nor does \ have any meaning in strings),
Quotes are not escaped by \ in ada (nor does \ have any meaning in strings),
so this turns out highlighting funny.
so this turns out highlighting funny.
<lang Ada>with Ada.Text_IO; use Ada.Text_IO;
<syntaxhighlight lang="ada">with Ada.Text_IO; use Ada.Text_IO;
with Ada.Strings.Fixed; use Ada.Strings.Fixed;
with Ada.Strings.Fixed; use Ada.Strings.Fixed;
procedure AsciiArt is
procedure AsciiArt is
Line 56: Line 116:
if i mod 3 = 0 then New_Line; Put(i/3*' '); end if;
if i mod 3 = 0 then New_Line; Put(i/3*' '); end if;
end loop;
end loop;
end AsciiArt;</lang>
end AsciiArt;</syntaxhighlight>
{{out}}
{{out}}
<pre>
<pre>
Line 68: Line 128:
\/\\\ \/\\\ \/\\\\\\\\\\\\ \/\\\\\\\\\\\\
\/\\\ \/\\\ \/\\\\\\\\\\\\ \/\\\\\\\\\\\\
\/// \/// \//////////// \////////////</pre>
\/// \/// \//////////// \////////////</pre>

=={{header|Arturo}}==

<syntaxhighlight lang="rebol">print {:
______ __
/\ _ \ /\ \__
\ \ \L\ \ _ __\ \ ,_\ __ __ _ __ ___
\ \ __ \/\`'__\ \ \/ /\ \/\ \/\`'__\/ __`\
\ \ \/\ \ \ \/ \ \ \_\ \ \_\ \ \ \//\ \L\ \
\ \_\ \_\ \_\ \ \__\\ \____/\ \_\\ \____/
\/_/\/_/\/_/ \/__/ \/___/ \/_/ \/___/
:}</syntaxhighlight>

{{out}}

<pre> ______ __
/\ _ \ /\ \__
\ \ \L\ \ _ __\ \ ,_\ __ __ _ __ ___
\ \ __ \/\`'__\ \ \/ /\ \/\ \/\`'__\/ __`\
\ \ \/\ \ \ \/ \ \ \_\ \ \_\ \ \ \//\ \L\ \
\ \_\ \_\ \_\ \ \__\\ \____/\ \_\\ \____/
\/_/\/_/\/_/ \/__/ \/___/ \/_/ \/___/</pre>


=={{header|AutoHotkey}}==
=={{header|AutoHotkey}}==
<lang autohotkey>AutoTrim, Off
<syntaxhighlight lang="autohotkey">AutoTrim, Off
draw =
draw =
(
(
Line 87: Line 169:


GuiClose:
GuiClose:
ExitApp</lang>
ExitApp</syntaxhighlight>
{{out}}
{{out}}
<pre> ______ __ __ __ __
<pre> ______ __ __ __ __
Line 97: Line 179:


=={{header|AWK}}==
=={{header|AWK}}==
<syntaxhighlight lang="awk">
<lang AWK>
# syntax: GAWK -f WRITE_LANGUAGE_NAME_IN_3D_ASCII.AWK
# syntax: GAWK -f WRITE_LANGUAGE_NAME_IN_3D_ASCII.AWK
BEGIN {
BEGIN {
Line 116: Line 198:
exit(0)
exit(0)
}
}
</syntaxhighlight>
</lang>
{{out}}
{{out}}
<pre>
<pre>
Line 128: Line 210:
_/ _/ _/ _/ _/ _/
_/ _/ _/ _/ _/ _/
</pre>
</pre>
=={{header|Batch File}}==
<lang batch>@echo off
echo ****** ** **
echo /*////** /** /**
echo /* /** ****** ****** ***** /**
echo /****** //////** ///**/ **///**/******
echo /*//// ** ******* /** /** // /**///**
echo /* /** **////** /** /** **/** /**
echo /******* //******** //** //***** /** /**
echo /////// //////// // ///// // // </lang>


=={{header|BASIC}}==
=={{header|BASIC}}==


==={{header|Applesoft BASIC}}===
==={{header|Applesoft BASIC}}===
Ported from [[Write language name in 3D ASCII#ZX Spectrum Basic|ZX Spectrum Basic]].<lang ApplesoftBasic>10 S$ = "BASIC" : REM OUR LANGUAGE NAME
Ported from [[Write language name in 3D ASCII#ZX Spectrum Basic|ZX Spectrum Basic]].<syntaxhighlight lang="applesoftbasic">10 S$ = "BASIC" : REM OUR LANGUAGE NAME
20 DIM B(5,5) : REM OUR BIGMAP CHARACTERS
20 DIM B(5,5) : REM OUR BIGMAP CHARACTERS
30 FOR L = 1 TO 5 : REM 5 CHARACTERS
30 FOR L = 1 TO 5 : REM 5 CHARACTERS
Line 190: Line 262:
9030 DATA 31,4,4,4,31: REM I
9030 DATA 31,4,4,4,31: REM I
9040 DATA 14,17,16,17,14: REM C
9040 DATA 14,17,16,17,14: REM C
</syntaxhighlight>
</lang>


==={{header|BBC BASIC}}===
==={{header|BBC BASIC}}===
{{works with|BBC BASIC for Windows}}
{{works with|BBC BASIC for Windows}}
Uses the built-in '''BBC Micro'''-compatible character generator, so any text can be specified.
Uses the built-in '''BBC Micro'''-compatible character generator, so any text can be specified.
<lang bbcbasic> PROC3dname("BBC BASIC")
<syntaxhighlight lang="bbcbasic"> PROC3dname("BBC BASIC")
END
END
Line 216: Line 288:
PRINT
PRINT
NEXT row%
NEXT row%
ENDPROC</lang>
ENDPROC</syntaxhighlight>
{{out}}
{{out}}
<pre>
<pre>
Line 231: Line 303:
==={{header|FreeBASIC}}===
==={{header|FreeBASIC}}===
freebasic is quite a long name, so I have done a combi.
freebasic is quite a long name, so I have done a combi.
<lang FreeBASIC>dim as integer yres=hiword(width)
<syntaxhighlight lang="freebasic">dim as integer yres=hiword(width)
dim as integer xres=loword(width)
dim as integer xres=loword(width)


Line 258: Line 330:
print "BASIC"
print "BASIC"
Sleep
Sleep
</syntaxhighlight>
</lang>
{{out}}
{{out}}
<pre> \ \ \ \ \ \ \ \ \ \ \ \
<pre> \ \ \ \ \ \ \ \ \ \ \ \
Line 279: Line 351:


==={{header|Liberty BASIC}}===
==={{header|Liberty BASIC}}===
<syntaxhighlight lang="lb">
<lang lb>
r=21:s=9:c=s
r=21:s=9:c=s
For i=1 To 11
For i=1 To 11
Line 298: Line 370:
Next
Next
Data 479667712,311470336,485697536,311699712,476292608,0,1976518785,1160267905,1171157123,1160267909,1171223529
Data 479667712,311470336,485697536,311699712,476292608,0,1976518785,1160267905,1171157123,1160267909,1171223529
</syntaxhighlight>
</lang>


{{out}}
{{out}}
Line 329: Line 401:


==={{header|Locomotive Basic}}===
==={{header|Locomotive Basic}}===
<lang locobasic>10 mode 2:defint a-z
<syntaxhighlight lang="locobasic">10 mode 2:defint a-z
20 locate 1,25
20 locate 1,25
30 print "Basic";
30 print "Basic";
Line 353: Line 425:
230 locate xp,yp+1
230 locate xp,yp+1
240 print "\\/";
240 print "\\/";
250 return</lang>
250 return</syntaxhighlight>


{{Out}}
{{Out}}
Line 368: Line 440:


==={{header|TI-83 BASIC}}===
==={{header|TI-83 BASIC}}===
<lang ti83b>Disp “ .....+ .....+
<syntaxhighlight lang="ti83b">Disp “ .....+ .....+
Disp “ +o+ooo +o+ooo
Disp “ +o+ooo +o+ooo
Disp “ .o .o
Disp “ .o .o
Line 374: Line 446:
Disp “ +o +ooooo
Disp “ +o +ooooo
Disp “
Disp “
Disp “ BASIC</lang>
Disp “ BASIC</syntaxhighlight>


Replace . + o with 0x81,0x80,and 0x7F http://tibasicdev.wikidot.com/one-byte-tokens
Replace . + o with 0x81,0x80,and 0x7F http://tibasicdev.wikidot.com/one-byte-tokens
Line 385: Line 457:
to cause a colour switch using a traditional space (ascii 32),
to cause a colour switch using a traditional space (ascii 32),
but the output would still look the same.
but the output would still look the same.
Fixed the error and removed the need for 2^z.

<lang zxbasic>10 LET s$="BASIC": REM our language name
<syntaxhighlight lang="zxbasic"> 10 DIM b(5,5): REM our bigmap characters
20 DIM b(5,5):REM our bigmap characters
20 FOR l=1 TO 5: REM 5 characters
30 FOR l = 1 TO 5: REM 5 characters
30 FOR m=1 TO 5: REM 5 rows
40 READ b(m,l)
40 FOR m = 1 TO 5: REM 5 rows
50 READ b(l,m)
50 NEXT m
60 NEXT m
60 NEXT l
70 PAPER 0: BORDER 0: REM black background and border
70 NEXT l
80 INK 2: REM our shadow will be red

90 CLS
100 PAPER 0: REM black background
110 INK 2: REM our shadow will be red
100 LET r=8: REM shadow will start on row 8
110 LET c=1: REM shadow will start at column 1
120 CLS
130 LET r=9: REM shadow will start on row 5
120 GO SUB 2000: REM draw shadow
140 LET c=2: REM shadow will start at column 2
130 INK 6: REM our foreground will be yellow
140 LET r=9: REM foreground will start on row 9
150 GO SUB 2000: REM draw shadow
160 INK 6: REM our forground will be yellow
150 LET c=2: REM foreground will start on column 2
160 GO SUB 2000: REM display the language name
170 LET r=10: REM foreground will start on row 6
999 STOP
180 LET c=3: REM foreground will start on column 3
190 GO SUB 2000: REM display the language name

999 STOP

1000 REM convert to binary bigmap
1000 REM convert to binary bigmap
1010 LET t=n: REM temporary variable
1010 LET z=16
1020 IF t>=z THEN PRINT AT r+l-1,c+c1;CHR$ (143);: LET t=t-z: REM 143 is a block
1020 LET g$="": REM this will contain our 5 character binary bigmap
1040 FOR z=5 TO 0 STEP -1
1040 LET c1=c1+1: LET z=z/2
1050 IF z>=1 THEN GO TO 1020
1050 LET d$=" ": REM assume next digit is zero (draw a space)
1060 RETURN
1060 IF t>=(2^z) THEN LET d$=CHR$(143): LET t=t-(2^z): LET sf=1: REM 143 is a block
1070 LET g$=g$+d$
1080 NEXT z
1090 RETURN

2000 REM display the big letters
2000 REM display the big letters
2010 FOR l=1 TO 5: REM our 5 rows
2010 FOR l=1 TO 5: LET c1=0: REM our 5 rows
2020 PRINT AT r+l-1,c;
2030 FOR m=1 TO 5: REM bigmap for each character
2030 FOR m=1 TO 5: REM bigmap for each character
2040 LET n=b(l,m)
2040 LET t=b(l,m)
2050 GO SUB 1000
2050 GO SUB 1000
2060 PRINT g$;: REM 5 character bigmap
2060 LET c1=c1+1: REM PRINT " ";: REM space between each letter
2070 NEXT m
2070 PRINT " ";: REM space between each letter
2080 NEXT m
2080 NEXT l
2090 NEXT l
2090 RETURN
2100 RETURN

9000 DATA 30,17,30,17,30: REM B
9000 DATA 30,17,30,17,30: REM B
9010 DATA 14,17,31,17,17: REM A
9010 DATA 14,17,31,17,17: REM A
9020 DATA 15,16,14,1,30: REM S
9020 DATA 15,16,14,1,30: REM S
9030 DATA 31,4,4,4,31: REM I
9030 DATA 31,4,4,4,31: REM I
9040 DATA 14,17,16,17,14: REM C</lang>
9040 DATA 14,17,16,17,14: REM C</syntaxhighlight>


To me it does not work. So I bring my particular solution:
To me it does not work. So I bring my particular solution:


<lang zxbasic>5 PAPER 0: CLS
<syntaxhighlight lang="zxbasic">5 PAPER 0: CLS
10 LET d=0: INK 1: GO SUB 40
10 LET d=0: INK 1: GO SUB 40
20 LET d=1: INK 6: GO SUB 40
20 LET d=1: INK 6: GO SUB 40
Line 454: Line 515:
150 DATA "XXX XXXX XXX X X "
150 DATA "XXX XXXX XXX X X "
160 DATA "X X X X X X X "
160 DATA "X X X X X X X "
170 DATA "XXX X X XXX X XXX"</lang>
170 DATA "XXX X X XXX X XXX"</syntaxhighlight>


[[File:Basic.jpg]]
[[File:Basic.jpg]]

=={{header|Batch File}}==
<syntaxhighlight lang="dos">@echo off
for %%b in (
""
" /####### ###### /######## ###### /## /##"
"| ##__ ## /##__ ##|__ ##__/ /##__ ##| ## | ##"
"| ## | ##| ## | ## | ## | ## \__/| ## | ##"
"| ####### | ######## | ## | ## | ########"
"| ##__ ##| ##__ ## | ## | ## | ##__ ##"
"| ## | ##| ## | ## | ## | ## /##| ## | ##"
"| #######/| ## | ## | ## | ######/| ## | ##"
"|_______/ |__/ |__/ |__/ \______/ |__/ |__/"
""
) do echo(%%~b
pause</syntaxhighlight>


=={{header|Befunge}}==
=={{header|Befunge}}==


===Befunge-93===
===Befunge-93===
<lang Befunge>0" &7&%h&'&%| &7&%7%&%&'&%&'&%&7&%"v
<syntaxhighlight lang="befunge">0" &7&%h&'&%| &7&%7%&%&'&%&'&%&7&%"v
v"'%$%'%$%3$%$%7% 0%&7&%&7&(%$%'%$"<
v"'%$%'%$%3$%$%7% 0%&7&%&7&(%$%'%$"<
>"%$%7%$%&%$%&'&%7%$%7%$%, '&+(%$%"v
>"%$%7%$%&%$%&'&%7%$%7%$%, '&+(%$%"v
Line 469: Line 546:
? ";(;(+(+$%+(%&(;(3%$%&$ 7`+( ":v >
? ";(;(+(+$%+(%&(;(3%$%&$ 7`+( ":v >
^v!:-1<\,:g7+*63%4 \/_#4:_v#:-*84_$@
^v!:-1<\,:g7+*63%4 \/_#4:_v#:-*84_$@
$_\:,\^ >55+,$:^:$</lang>
$_\:,\^ >55+,$:^:$</syntaxhighlight>
{{out}}
{{out}}
<pre>
<pre>
Line 485: Line 562:
(It adds line offset to those strings,and the strings are encoded with numbers just because.)
(It adds line offset to those strings,and the strings are encoded with numbers just because.)
{{works with|CCBI|2.1}}
{{works with|CCBI|2.1}}
<syntaxhighlight lang="befunge">
<lang Befunge>
v THE DATA IMAGE.(totally useless after loading into stack)
v THE DATA IMAGE.(totally useless after loading into stack)
>89 v Made by gamemanj
>89 v Made by gamemanj
Line 521: Line 598:
" "
" "
^ $,< < < (code path reuse here,all 3 end in ,$ so I merged them)
^ $,< < < (code path reuse here,all 3 end in ,$ so I merged them)
</syntaxhighlight>
</lang>
{{out}}
{{out}}
<pre>
<pre>
Line 533: Line 610:
</pre>
</pre>


=={{header|Binary Lambda Calculus}}==

Using the fact that an asterisk at the start of a program copies the rest to stdout:

<pre>* ____
/\ _`\ __
\ \ \L\ \ /\_\ ___ __ _ __ __ __
\ \ _ <'\/\ \ /' _ `\ /'__`\ /\`'__\/\ \/\ \
\ \ \L\ \\ \ \/\ \/\ \/\ \L\.\_\ \ \/ \ \ \_\ \
\ \____/ \ \_\ \_\ \_\ \__/.\_\\ \_\ \/`____ \
\/___/ \/_/\/_/\/_/\/__/\/_/ \/_/ `/___/> \
__ __ __ /\___/
/\ \ /\ \ /\ \ \/__/
\ \ \ __ ___ ___\ \ \____ \_\ \ __
\ \ \ __ /'__`\ /' __` __`\ \ '__`\ /'_` \ /'__`\
\ \ \L\ \/\ \L\.\_/\ \/\ \/\ \ \ \L\ \/\ \L\ \/\ \L\.\_
\ \____/\ \__/.\_\ \_\ \_\ \_\ \_,__/\ \___,_\ \__/.\_\
\/___/ \/__/\/_/\/_/\/_/\/_/\/___/ \/__,_ /\/__/\/_/
____ ___ ___
/\ _`\ /\_ \ /\_ \
\ \ \/\_\ __ \//\ \ ___ __ __\//\ \ __ __ ____
\ \ \/_/_ /'__`\ \ \ \ /'___\/\ \/\ \ \ \ \ /\ \/\ \ /',__\
\ \ \L\ \/\ \L\.\_ \_\ \_/\ \__/\ \ \_\ \ \_\ \_\ \ \_\ \/\__, `\
\ \____/\ \__/.\_\/\____\ \____\\ \____/ /\____\\ \____/\/\____/
\/___/ \/__/\/_/\/____/\/____/ \/___/ \/____/ \/___/ \/___/</pre>


=={{header|Brainf***}}==
=={{header|Brainf***}}==
Coming up with decent 3D font was honestly the hardest part.
Coming up with decent 3D font was honestly the hardest part.
<lang bf>++++[>++++>++<[>>++>+++>++++++> ++++++<<<<<-]<-]>>++>..>->---->
<syntaxhighlight lang="bf">++++[>++++>++<[>>++>+++>++++++> ++++++<<<<<-]<-]>>++>..>->---->
-...[<]<+++[>++++[>>...<<-]<-]> >>..>>>.....<<<..>>>...[<]++[>>
-...[<]<+++[>++++[>>...<<-]<-]> >>..>>>.....<<<..>>>...[<]++[>>
.....>>>...<<<<<-]>.>.>.>.<<..> >.[<]<+++++[>++++[>>.<<-]<-]>>>
.....>>>...<<<<<-]>.>.>.>.<<..> >.[<]<+++++[>++++[>>.<<-]<-]>>>
Line 551: Line 653:
..>>.<<.>>.>......<..>..<.<<..> >.<<.>>.>...<<.>.>..<..>..<..>.
..>>.<<.>>.>......<..>..<.<<..> >.<<.>>.>...<<.>.>..<..>..<..>.
.<..<<.>>.>..<..>..<.<<<.>..... .>>.<.>>......<<..>>..<<.<...>>
.<..<<.>>.>..<..>..<.<<<.>..... .>>.<.>>......<<..>>..<<.<...>>
.<.>>..<<.>.<.>>..<<..>>..<<..> >..<<.<.>>.<.>>..<<..>>..<<.<<.</lang>
.<.>>..<<.>.<.>>..<<..>>..<<..> >..<<.<.>>.<.>>..<<..>>..<<.<<.</syntaxhighlight>
{{out}}
{{out}}
<pre>
<pre>
Line 565: Line 667:


=={{header|C}}==
=={{header|C}}==
3D enough?<lang c>#include <stdio.h>
3D enough?<syntaxhighlight lang="c">#include <stdio.h>
const char*s = " _____\n /____/\\\n/ ___\\/\n\\ \\/__/\n \\____/";
const char*s = " _____\n /____/\\\n/ ___\\/\n\\ \\/__/\n \\____/";
int main(){ puts(s); return 0; }</lang>
int main(){ puts(s); return 0; }</syntaxhighlight>
{{out}}
{{out}}
<pre>
<pre>
Line 577: Line 679:
</pre>
</pre>


=={{header|C sharp|C#}}==
<syntaxhighlight lang="csharp">using System;
using System.Text;

namespace Language_name_in_3D_ascii
{
public class F5
{
char[] z = { ' ', ' ', '_', '/', };
long[,] f ={
{87381,87381,87381,87381,87381,87381,87381,},
{349525,375733,742837,742837,375733,349525,349525,},
{742741,768853,742837,742837,768853,349525,349525,},
{349525,375733,742741,742741,375733,349525,349525,},
{349621,375733,742837,742837,375733,349525,349525,},
{349525,375637,768949,742741,375733,349525,349525,},
{351157,374101,768949,374101,374101,349525,349525,},
{349525,375733,742837,742837,375733,349621,351157,},
{742741,768853,742837,742837,742837,349525,349525,},
{181,85,181,181,181,85,85,},
{1461,1365,1461,1461,1461,1461,2901,},
{742741,744277,767317,744277,742837,349525,349525,},
{181,181,181,181,181,85,85,},
{1431655765,3149249365L,3042661813L,3042661813L,3042661813L,1431655765,1431655765,},
{349525,768853,742837,742837,742837,349525,349525,},
{349525,375637,742837,742837,375637,349525,349525,},
{349525,768853,742837,742837,768853,742741,742741,},
{349525,375733,742837,742837,375733,349621,349621,},
{349525,744373,767317,742741,742741,349525,349525,},
{349525,375733,767317,351157,768853,349525,349525,},
{374101,768949,374101,374101,351157,349525,349525,},
{349525,742837,742837,742837,375733,349525,349525,},
{5592405,11883957,11883957,5987157,5616981,5592405,5592405,},
{366503875925L,778827027893L,778827027893L,392374737749L,368114513237L,366503875925L,366503875925L,},
{349525,742837,375637,742837,742837,349525,349525,},
{349525,742837,742837,742837,375733,349621,375637,},
{349525,768949,351061,374101,768949,349525,349525,},
{375637,742837,768949,742837,742837,349525,349525,},
{768853,742837,768853,742837,768853,349525,349525,},
{375733,742741,742741,742741,375733,349525,349525,},
{192213,185709,185709,185709,192213,87381,87381,},
{1817525,1791317,1817429,1791317,1817525,1398101,1398101,},
{768949,742741,768853,742741,742741,349525,349525,},
{375733,742741,744373,742837,375733,349525,349525,},
{742837,742837,768949,742837,742837,349525,349525,},
{48053,23381,23381,23381,48053,21845,21845,},
{349621,349621,349621,742837,375637,349525,349525,},
{742837,744277,767317,744277,742837,349525,349525,},
{742741,742741,742741,742741,768949,349525,349525,},
{11883957,12278709,11908533,11883957,11883957,5592405,5592405,},
{11883957,12277173,11908533,11885493,11883957,5592405,5592405,},
{375637,742837,742837,742837,375637,349525,349525,},
{768853,742837,768853,742741,742741,349525,349525,},
{6010197,11885397,11909973,11885397,6010293,5592405,5592405,},
{768853,742837,768853,742837,742837,349525,349525,},
{375733,742741,375637,349621,768853,349525,349525,},
{12303285,5616981,5616981,5616981,5616981,5592405,5592405,},
{742837,742837,742837,742837,375637,349525,349525,},
{11883957,11883957,11883957,5987157,5616981,5592405,5592405,},
{3042268597L,3042268597L,3042661813L,1532713813,1437971797,1431655765,1431655765,},
{11883957,5987157,5616981,5987157,11883957,5592405,5592405,},
{11883957,5987157,5616981,5616981,5616981,5592405,5592405,},
{12303285,5593941,5616981,5985621,12303285,5592405,5592405,}
};

private F5(string s)
{
StringBuilder[] o = new StringBuilder[7];
for (int i = 0; i < 7; i++) o[i] = new StringBuilder();
for (int i = 0, l = s.Length; i < l; i++)
{
int c = s[i];
if (65 <= c && c <= 90) c -= 39;
else if (97 <= c && c <= 122) c -= 97;
else c = -1;
long[] d = new long[7];
Buffer.BlockCopy(f, (++c * sizeof(long) * 7), d, 0, 7 * sizeof(long));
for (int j = 0; j < 7; j++)
{
StringBuilder b = new StringBuilder();
long v = d[j];
while (v > 0)
{
b.Append(z[(int)(v & 3)]);
v >>= 2;
}
char[] charArray = b.ToString().ToCharArray();
Array.Reverse(charArray);
o[j].Append(new string(charArray));
}
}
for (int i = 0; i < 7; i++)
{
for (int j = 0; j < 7 - i; j++)
System.Console.Write(' ');
System.Console.WriteLine(o[i]);
}
}

public static void Main(string[] args)
{
new F5(args.Length > 0 ? args[0] : "C sharp");
}
}
}</syntaxhighlight>

Output:
<pre> _/_/_/ _/
_/ _/_/_/ _/_/_/ _/_/_/ _/ _/_/ _/_/_/
_/ _/_/ _/ _/ _/ _/ _/_/ _/ _/
_/ _/_/ _/ _/ _/ _/ _/ _/ _/
_/_/_/ _/_/_/ _/ _/ _/_/_/ _/ _/_/_/
_/
_/</pre>


=={{header|C++}}==
=={{header|C++}}==
<lang cpp>
<syntaxhighlight lang="cpp">
#include <windows.h>
#include <windows.h>
#include <iostream>
#include <iostream>
Line 609: Line 825:
}
}
//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
</syntaxhighlight>
</lang>
{{out}}
{{out}}
<pre>
<pre>
Line 627: Line 843:
</pre>
</pre>
Another solution:
Another solution:
<lang cpp>
<syntaxhighlight lang="cpp">
// @author Martin Ettl (http://www.martinettl.de)
// @author Martin Ettl (http://www.martinettl.de)
// @date 2013-07-26
// @date 2013-07-26
Line 651: Line 867:
return 0;
return 0;
}
}
</syntaxhighlight>
</lang>
{{out}}
{{out}}
<pre>
<pre>
Line 667: Line 883:
=={{header|Clojure}}==
=={{header|Clojure}}==
{{libheader|clj-figlet}}
{{libheader|clj-figlet}}
<lang clojure>(use 'clj-figlet.core)
<syntaxhighlight lang="clojure">(use 'clj-figlet.core)
(println
(println
(render-to-string
(render-to-string
(load-flf "ftp://ftp.figlet.org/pub/figlet/fonts/contributed/larry3d.flf")
(load-flf "ftp://ftp.figlet.org/pub/figlet/fonts/contributed/larry3d.flf")
"Clojure"))</lang>
"Clojure"))</syntaxhighlight>


{{out}}
{{out}}
Line 685: Line 901:
\/___/
\/___/
</pre>
</pre>



=={{header|COBOL}}==
=={{header|COBOL}}==
This displays 'COBOL' in 3D with a shadow effect. The font is 'Slant Relief' from [http://http://patorjk.com/software/taag/ here].
This displays 'COBOL' in 3D with a shadow effect. The font is 'Slant Relief' from [http://http://patorjk.com/software/taag/ here].
{{works with|OpenCOBOL}}
{{works with|OpenCOBOL}}
<lang cobol> IDENTIFICATION DIVISION.
<syntaxhighlight lang="cobol"> IDENTIFICATION DIVISION.
PROGRAM-ID. cobol-3d.
PROGRAM-ID. cobol-3d.


Line 767: Line 982:


GOBACK
GOBACK
.</lang>
.</syntaxhighlight>


{{out}} (note: the shadow effect is quite faint on this site):
{{out}} (note: the shadow effect is quite faint on this site):
Line 784: Line 999:
=={{header|Common Lisp}}==
=={{header|Common Lisp}}==
{{libheader|cl-ppcre}}
{{libheader|cl-ppcre}}
<lang lisp>
<syntaxhighlight lang="lisp">
(ql:quickload :cl-ppcre)
(ql:quickload :cl-ppcre)
(defvar txt
(defvar txt
Line 797: Line 1,012:
)
)
(princ (cl-ppcre:regex-replace-all " " (cl-ppcre:regex-replace-all "x" txt "_/") " " ))
(princ (cl-ppcre:regex-replace-all " " (cl-ppcre:regex-replace-all "x" txt "_/") " " ))
</syntaxhighlight>
</lang>
{{out}}
{{out}}
<pre>
<pre>
Line 808: Line 1,023:


</pre>
</pre>

=={{header|ContextFree}}==
<syntaxhighlight lang="contextfree">
startshape START

shape START {
loop i = 6 [y -1 x -1 z 10] NAME [b 1-((i+1)*0.11)]
}

shape NAME {
C [ x 34 z 1]
O [ x 46 z 2]
N [ x 64 z 3]
T [ x 85 z 4]
E [ x 95 z 5]
X [ x 106 z 6]
T [ x 125 z 7]
HYPHEN[x 135]

F [ x 145 z 8]
R [ x 158 z 9]
E [ x 175 z 10]
E [ x 188 z 11]

}

shape C {
ARCL [ y 12 flip 90 ]
ARCL [ y 12 r 180 ]
}


shape E {
LINE [ s 0.9 ]
LINE [ s 0.9 -1 y 24 ]
LINE [ s 0.4 r -90 y 0 ]
LINE [ s 0.4 r -90 y 12 ]
LINE [ s 0.4 r -90 y 24 ]
}

shape F {
LINE [ s 0.9 -1 y 24 ]
LINE [ s 0.4 r -90 y 12 ]
LINE [ s 0.4 r -90 y 24 ]
}


shape M {
LINE [ y 24 r 180 ]
LINE [ y 24 r -160 s 0.75 ]
LINE [ y 24 x 12 r 160 s 0.75 ]
LINE [ y 24 x 12 r 180 ]
}

shape N {
LINE [ y 24 r 180 ]
LINE [ y 24 r -160 ]
LINE [ y 24 x 9 r 180 ]
}

shape O {
ARCL [ y 12 flip 90]
ARCL [ y 12 r 180 ]
ARCL [ y 12 x 14 r 180 flip 90]
ARCL [ y 12 x 14 ]
}

shape R {
LINE [ s 0.9 -1 y 24 ]
LINE [ s 0.4 r -90 y 12 ]
LINE [ s 0.4 r -90 y 24 ]
LINE [ y 12 r -140 s 0.65 ]

ARCL [ y 18 x 12 r 180 flip 90 s 0.8 0.5]
ARCL [ y 18 x 12 s 0.8 0.5 ]

}

shape T {
LINE [ s 0.9 -1 y 24 ]
LINE [ s 0.4 r -90 y 24 ]
LINE [ s 0.4 r 90 y 24 ]
}

shape X {
LINE [ x 8 y 24 r 160 ]
LINE [ y 24 r -160 ]
}

shape HYPHEN{
SQUARE[y 11.5 s 4 0.5]
}

shape LINE {
TRIANGLE [[ s 1 30 y 0.26 ]]

}

shape ARCL {
SQUARE [ ]
ARCL [ size 0.97 y 0.55 r 1.5 ]
}
</syntaxhighlight>
{{out}}
[https://www.contextfreeart.org/gallery/view.php?id=4205 Output Image]


=={{header|D}}==
=={{header|D}}==
This generates a single image ASCII stereogram.
This generates a single image ASCII stereogram.
<lang d>// Derived from AA3D - ASCII art stereogram generator
<syntaxhighlight lang="d">// Derived from AA3D - ASCII art stereogram generator
// by Jan Hubicka and Thomas Marsh
// by Jan Hubicka and Thomas Marsh
// (GNU General Public License)
// (GNU General Public License)
Line 869: Line 1,191:
writeln();
writeln();
}
}
}</lang>
}</syntaxhighlight>
{{out}}
{{out}}
<pre>nguageDLangunguageDLangunguageDLangunguageDLangung
<pre>nguageDLangunguageDLangunguageDLangunguageDLangung
Line 883: Line 1,205:
geDLanguageDgeDLanuageDgeDLanuageeDgeDLanuageeDgeD
geDLanguageDgeDLanuageDgeDLanuageeDgeDLanuageeDgeD
guageDLanguaguageDLanguaguageDLanguaguageDLanguagu</pre>
guageDLanguaguageDLanguaguageDLanguaguageDLanguagu</pre>

=={{header|Dart}}==
<syntaxhighlight lang="dart">
void main(){
print("""

XXX XX XXX XXXX
X X X X X X X
X X XXXX XXX X
XXX X X X X X
""".replaceAll('X','_/'));
}
</syntaxhighlight>
{{out}}
<pre>

_/_/_/ _/_/ _/_/_/ _/_/_/_/
_/ _/ _/ _/ _/ _/ _/
_/ _/ _/_/_/_/ _/_/_/ _/
_/_/_/ _/ _/ _/ _/ _/

</pre>
=={{header|Delphi}}==
{{libheader| System.SysUtils}}
{{Trans|Java}}
<syntaxhighlight lang="delphi">
program Write_language_name_in_3D_ASCII;

{$APPTYPE CONSOLE}

uses
System.SysUtils;

const
z: TArray<char> = [' ', ' ', '_', '/'];
f: TArray<TArray<Cardinal>> = [[87381, 87381, 87381, 87381, 87381, 87381,
87381], [349525, 375733, 742837, 742837, 375733, 349525, 349525], [742741,
768853, 742837, 742837, 768853, 349525, 349525], [349525, 375733, 742741,
742741, 375733, 349525, 349525], [349621, 375733, 742837, 742837, 375733,
349525, 349525], [349525, 375637, 768949, 742741, 375733, 349525, 349525], [351157,
374101, 768949, 374101, 374101, 349525, 349525], [349525, 375733, 742837,
742837, 375733, 349621, 351157], [742741, 768853, 742837, 742837, 742837,
349525, 349525], [181, 85, 181, 181, 181, 85, 85], [1461, 1365, 1461, 1461,
1461, 1461, 2901], [742741, 744277, 767317, 744277, 742837, 349525, 349525],
[181, 181, 181, 181, 181, 85, 85], [1431655765, 3149249365, 3042661813,
3042661813, 3042661813, 1431655765, 1431655765], [349525, 768853, 742837,
742837, 742837, 349525, 349525], [349525, 375637, 742837, 742837, 375637,
349525, 349525], [349525, 768853, 742837, 742837, 768853, 742741, 742741], [349525,
375733, 742837, 742837, 375733, 349621, 349621], [349525, 744373, 767317,
742741, 742741, 349525, 349525], [349525, 375733, 767317, 351157, 768853,
349525, 349525], [374101, 768949, 374101, 374101, 351157, 349525, 349525], [349525,
742837, 742837, 742837, 375733, 349525, 349525], [5592405, 11883957,
11883957, 5987157, 5616981, 5592405, 5592405], [366503875925, 778827027893,
778827027893, 392374737749, 368114513237, 366503875925, 366503875925], [349525,
742837, 375637, 742837, 742837, 349525, 349525], [349525, 742837, 742837,
742837, 375733, 349621, 375637], [349525, 768949, 351061, 374101, 768949,
349525, 349525], [375637, 742837, 768949, 742837, 742837, 349525, 349525], [768853,
742837, 768853, 742837, 768853, 349525, 349525], [375733, 742741, 742741,
742741, 375733, 349525, 349525], [192213, 185709, 185709, 185709, 192213,
87381, 87381], [1817525, 1791317, 1817429, 1791317, 1817525, 1398101,
1398101], [768949, 742741, 768853, 742741, 742741, 349525, 349525], [375733,
742741, 744373, 742837, 375733, 349525, 349525], [742837, 742837, 768949,
742837, 742837, 349525, 349525], [48053, 23381, 23381, 23381, 48053, 21845,
21845], [349621, 349621, 349621, 742837, 375637, 349525, 349525], [742837,
744277, 767317, 744277, 742837, 349525, 349525], [742741, 742741, 742741,
742741, 768949, 349525, 349525], [11883957, 12278709, 11908533, 11883957,
11883957, 5592405, 5592405], [11883957, 12277173, 11908533, 11885493,
11883957, 5592405, 5592405], [375637, 742837, 742837, 742837, 375637, 349525,
349525], [768853, 742837, 768853, 742741, 742741, 349525, 349525], [6010197,
11885397, 11909973, 11885397, 6010293, 5592405, 5592405], [768853, 742837,
768853, 742837, 742837, 349525, 349525], [375733, 742741, 375637, 349621,
768853, 349525, 349525], [12303285, 5616981, 5616981, 5616981, 5616981,
5592405, 5592405], [742837, 742837, 742837, 742837, 375637, 349525, 349525],
[11883957, 11883957, 11883957, 5987157, 5616981, 5592405, 5592405], [3042268597,
3042268597, 3042661813, 1532713813, 1437971797, 1431655765, 1431655765], [11883957,
5987157, 5616981, 5987157, 11883957, 5592405, 5592405], [11883957, 5987157,
5616981, 5616981, 5616981, 5592405, 5592405], [12303285, 5593941, 5616981,
5985621, 12303285, 5592405, 5592405]];

function ReverseString(s: string): string;
var
i, len: integer;
begin
len := s.Length;
SetLength(Result, len);
for i := 1 to len do
Result[len - i + 1] := s[i];
end;

procedure F5(s: ansistring);
begin
var o: TArray<TStringBuilder>;
SetLength(o, 7);
for var i := 0 to High(o) do
o[i] := TStringBuilder.Create;

var l := length(s);
for var i := 1 to l do
begin
var c: Integer := ord(s[i]);
if c in [65..90] then
c := c - 39
else if c in [97..122] then
c := c - 97
else
c := -1;

inc(c);
var d: TArray<Cardinal> := f[c];
for var j := 0 to 6 do
begin
var b := TStringBuilder.Create;
var v := d[j];

while v > 0 do
begin
b.Append(z[Trunc(v and 3)]);
v := v shr 2;
end;
o[j].Append(ReverseString(b.ToString));
b.Free;
end;
end;
for var i := 0 to 6 do
begin
for var j := 0 to 6 - i do
write(' ');
writeln(o[i].ToString);
end;

for var i := 0 to High(o) do
o[i].Free;
end;

begin
F5('Delphi');
F5('Thanks Java');
F5('guy');
readln;
end.</syntaxhighlight>
{{out}}
<pre> _/_/_/ _/ _/ _/
_/ _/ _/_/ _/ _/_/_/ _/_/_/
_/ _/ _/_/_/_/ _/ _/ _/ _/ _/ _/
_/ _/ _/ _/ _/ _/ _/ _/ _/
_/_/_/ _/_/_/ _/ _/_/_/ _/ _/ _/
_/
_/
_/_/_/_/_/ _/ _/ _/
_/ _/_/_/ _/_/_/ _/_/_/ _/ _/ _/_/_/ _/ _/_/_/ _/ _/ _/_/_/
_/ _/ _/ _/ _/ _/ _/ _/_/ _/_/ _/ _/ _/ _/ _/ _/ _/
_/ _/ _/ _/ _/ _/ _/ _/ _/ _/_/ _/ _/ _/ _/ _/ _/ _/ _/
_/ _/ _/ _/_/_/ _/ _/ _/ _/ _/_/_/ _/_/ _/_/_/ _/ _/_/_/



_/_/_/ _/ _/ _/ _/
_/ _/ _/ _/ _/ _/
_/ _/ _/ _/ _/ _/
_/_/_/ _/_/_/ _/_/_/
_/ _/
_/_/ _/_/</pre>


=={{header|Elixir}}==
=={{header|Elixir}}==
<lang elixir>defmodule ASCII3D do
<syntaxhighlight lang="elixir">defmodule ASCII3D do
def decode(str) do
def decode(str) do
Regex.scan(~r/(\d+)(\D+)/, str)
Regex.scan(~r/(\d+)(\D+)/, str)
Line 897: Line 1,381:
2 3 B5_1/4 6 B3 1B/_/2 /1_2 6 B1\n3 3 B10_6 B3 3 /2B_1_6 B1
2 3 B5_1/4 6 B3 1B/_/2 /1_2 6 B1\n3 3 B10_6 B3 3 /2B_1_6 B1
4 2 B11_2B 1B_B2 B1_B 3 /1B/_/B_B2 B B_B1\n6 1B/11_1/3 B/_/2 3 B/_/"
4 2 B11_2B 1B_B2 B1_B 3 /1B/_/B_B2 B B_B1\n6 1B/11_1/3 B/_/2 3 B/_/"
IO.puts ASCII3D.decode(data)</lang>
IO.puts ASCII3D.decode(data)</syntaxhighlight>


{{out}}
{{out}}
Line 913: Line 1,397:


=={{header|Erlang}}==
=={{header|Erlang}}==
<lang erlang>%% Implemented by Arjun Sunel
<syntaxhighlight lang="erlang">%% Implemented by Arjun Sunel
-module(three_d).
-module(three_d).
-export([main/0]).
-export([main/0]).
Line 919: Line 1,403:
main() ->
main() ->
io:format(" _____ _ \n| ___| | | \n| |__ _ __| | __ _ _ __ __ _ \n| __| '__| |/ _` | '_ \\ / _` |\n| |__| | | | (_| | | | | (_| |\n|____/_| |_|\\__,_|_| |_|\\__, |\n __/ |\n |___/\n").
io:format(" _____ _ \n| ___| | | \n| |__ _ __| | __ _ _ __ __ _ \n| __| '__| |/ _` | '_ \\ / _` |\n| |__| | | | (_| | | | | (_| |\n|____/_| |_|\\__,_|_| |_|\\__, |\n __/ |\n |___/\n").
</syntaxhighlight>
</lang>
{{out}}
{{out}}
<pre>
<pre>
Line 930: Line 1,414:
__/ |
__/ |
|___/
|___/
</pre>


'''3D ASCII:'''
{{trans|Elixir}}
<syntaxhighlight lang="erlang">-module(ascii3d).
-export([decode/1]).

decode(Str) ->
Splited = re:split(Str, "(\\d+)(\\D+)", [{return,list},group,trim]),
Fun = fun([_,N,S]) -> {Num,_} = string:to_integer(N), lists:duplicate(Num, S) end,
Joined = string:join(lists:flatmap(Fun, Splited), ""),
Lines = binary:replace(binary:list_to_bin(Joined), <<"B">>, <<"\\">>, [global]),
io:format("~s~n", [Lines]).</syntaxhighlight>
{{out}}
<pre>
1> c("ascii3d.erl").
{ok,ascii3d}
2> Str = "1 11_10 2_1\n1/B2 8_1B8 1/B B\n2B 1B7_1/7 3 B1\n3 B7_6 3_3B 3 6_2 2_2 4_4 6_1\n2 2B 1 6_1B4 1/ 3_3B 1 / 4_1 B/B B/ 2_1 B2 1/ 4_1 B\n2 3 B5_1/3 1/B B2_1/B2 B1/B B2_1/3B 1 /_2/B B2_1/B B\n3 3 B8_3B 1 5 B1_B/ 8 B1_B/ B\n4 2 B10_1B B_B3 2B B_3_1/2B_B 2B B_3_1/B B\n6 1B/10_1/B/_/4 1B/_/B/3_2/B/_1/2 1B/_/B/3_1/2B 1B\n55 3_1B/2 1)\n54 1/B5_1/\n54 1B/4_1/\n".
"1 11_10 2_1\n1/B2 8_1B8 1/B B\n2B 1B7_1/7 3 B1\n3 B7_6 3_3B 3 6_2 2_2 4_4 6_1\n2 2B 1 6_1B4 1/ 3_3B 1 / 4_1 B/B B/ 2_1 B2 1/ 4_1 B\n2 3 B5_1/3 1/B B2_1/B2 B1/B B2_1/3B 1 /_2/B B2_1/B B\n3 3 B8_3B 1 5 B1_B/ 8 B1_B/ B\n4 2 B10_1B B_B3 2B B_3_1/2B_B 2B B_3_1/B B\n6 1B/10_1/B/_/4 1B/_/B/3_2/B/_1/2 1B/_/B/3_1/2B 1B\n55 3_1B/2 1)\n54 1/B5_1/\n54 1B/4_1/\n"
3> ascii3d:decode(Str).
___________ __
/\ ________\ /\ \
\ \ \_______/ \ \ \
\ \ \_______ ___\ \ \ ______ __ ____ ______
\ \ ______\ / ___\ \ \ / ____ \/\ \/ __ \ / ____ \
\ \ \_____/ /\ \__/\ \ \/\ \__/\ \ \ /_/\ \/\ \__/\ \
\ \ \________\ \ \ \ \ \ \ \_\/ \ \ \ \ \ \ \ \_\/ \
\ \__________\ \_\ \ \_\ \____/\_\ \_\ \ \_\ \____/\ \
\/__________/\/_/ \/_/\/___/\/_/\/_/ \/_/\/___/\ \ \
___\/ )
/\_____/
\/____/

ok
</pre>
</pre>


=={{header|ERRE}}==
=={{header|ERRE}}==
<lang ERRE>PROGRAM 3D_NAME
<syntaxhighlight lang="erre">PROGRAM 3D_NAME


DIM TBL$[17,1]
DIM TBL$[17,1]
Line 969: Line 1,488:


END PROGRAM
END PROGRAM
</syntaxhighlight>
</lang>
{{out}}
{{out}}
<pre>
<pre>
Line 993: Line 1,512:


=={{header|F_Sharp|F#}}==
=={{header|F_Sharp|F#}}==
<lang fsharp>let make2Darray (picture : string list) =
<syntaxhighlight lang="fsharp">let make2Darray (picture : string list) =
let maxY = picture.Length
let maxY = picture.Length
let maxX = picture |> List.maxBy String.length |> String.length
let maxX = picture |> List.maxBy String.length |> String.length
Line 1,036: Line 1,555:
if x = 0 then printfn ""
if x = 0 then printfn ""
printf "%c" c) a2
printf "%c" c) a2
</syntaxhighlight>
</lang>
{{out}}
{{out}}
<pre>
<pre>
Line 1,053: Line 1,572:
=={{header|Forth}}==
=={{header|Forth}}==
=== Text strings ===
=== Text strings ===
<lang FORTH>\ Rossetta Code Write language name in 3D ASCII
<syntaxhighlight lang="forth">\ Rossetta Code Write language name in 3D ASCII
\ Simple Method
\ Simple Method


Line 1,070: Line 1,589:
( test at the console )
( test at the console )
page "forth"
page "forth"
</syntaxhighlight>
</lang>


{{out}}
{{out}}
Line 1,090: Line 1,609:


=== Bit Matrix Method ===
=== Bit Matrix Method ===
<lang FORTH>\ Original code: "Short phrases with BIG Characters by Wil Baden 2003-02-23
<syntaxhighlight lang="forth">\ Original code: "Short phrases with BIG Characters by Wil Baden 2003-02-23
\ Modified BFox for simple 3D presentation 2015-07-14
\ Modified BFox for simple 3D presentation 2015-07-14


Line 1,192: Line 1,711:
\ test the solution in the Forth console
\ test the solution in the Forth console


</syntaxhighlight>
</LANG>


{{out}}
{{out}}
Line 1,217: Line 1,736:


</pre>
</pre>


=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">
_window = 1
begin enum 1
_asciiField
end enum

void local fn BuildWindow
CGRect r = fn CGRectMake( 0, 0, 610, 140 )
window _window, @"Rosetta Code — FutureBasic in 3D ASCII", r, NSWindowStyleMaskTitled + NSWindowStyleMaskClosable
WindowSetBackgroundColor( _window, fn ColorBlack )
CFStringRef asciiFB = @" ¬
/$$$$$$$$ / $$ /$$$$$$$ /$$ \n¬
| $$_____/ | $$ | $$__ $$ |__/ \n¬
| $$ /$$ /$$ /$$$$$$ /$$ /$$ /$$$$$$ /$$$$$$ | $$ \\ $$ /$$$$$$ /$$$$$$$ /$$ /$$$$$$$\n¬
| $$$$$ | $$ | $$|_ $$_/ | $$ | $$ /$$__ $$ /$$__ $$| $$$$$$$ |____ $$ /$$_____/| $$ /$$_____/\n¬
| $$__/ | $$ | $$ | $$ | $$ | $$| $$ \\__/| $$$$$$$$| $$__ $$ /$$$$$$$| $$$$$$ | $$| $$ \n¬
| $$ | $$ | $$ | $$ /$$| $$ | $$| $$ | $$_____/| $$ \\ $$ /$$__ $$ \\____ $$| $$| $$ \n¬
| $$ | $$$$$$/ | $$$$/| $$$$$$/| $$ | $$$$$$$| $$$$$$$/| $$$$$$$ /$$$$$$$/| $$| $$$$$$$\n¬
|__/ \\______/ \\___/ \\______/ |__/ \\_______/|_______/ \\_______/|_______/ |__/ \\_______/\n"
r = fn CGRectMake( 22, 20, 582, 100 )
textfield _asciiField, YES, asciiFB, r, _window
TextFieldSetTextColor( _asciiField, fn ColorYellow )
TextFieldSetBordered( _asciiField, NO )
TextFieldSetBackgroundColor( _asciiField, fn ColorBlack )
ControlSetFontWithName( _asciiField, @"Menlo", 9.0 )
end fn

void local fn DoDialog( ev as long, tag as long, wnd as long )
select ( ev )
case _windowWillClose : end
end select
end fn

on dialog fn DoDialog

fn BuildWindow

HandleEvents
</syntaxhighlight>
{{output}}
[[File:FutureBasic in ASCII Art.png]]




=={{header|Go}}==
=={{header|Go}}==
Line 1,222: Line 1,789:


For the interest component of the task, I thought about rendering the result from an input string and realized that it wasn't completely trivial as the glyphs of the Lean font overlap with the standard letter spacing. Rendering different fonts would add interest because now there would be a point in developing a common font representation and rendering function. Block and Lean would have sufficed, but I looked further and found the Keyboard and Small Keyboard fonts. These I found somewhat amusing, for the final component of the task.
For the interest component of the task, I thought about rendering the result from an input string and realized that it wasn't completely trivial as the glyphs of the Lean font overlap with the standard letter spacing. Rendering different fonts would add interest because now there would be a point in developing a common font representation and rendering function. Block and Lean would have sufficed, but I looked further and found the Keyboard and Small Keyboard fonts. These I found somewhat amusing, for the final component of the task.
<lang go>package main
<syntaxhighlight lang="go">package main


import (
import (
Line 1,314: Line 1,881:
fmt.Println(render("Go", lean))
fmt.Println(render("Go", lean))
fmt.Println(render("Go", smallKeyboard))
fmt.Println(render("Go", smallKeyboard))
}</lang>
}</syntaxhighlight>
{{out}}
{{out}}
<pre>
<pre>
Line 1,330: Line 1,897:
=={{header|Groovy}}==
=={{header|Groovy}}==
A simple way to display ASCII art
A simple way to display ASCII art
<lang Groovy>println """\
<syntaxhighlight lang="groovy">println """\
_|_|_|
_|_|_|
_| _| _|_| _|_| _|_| _| _| _| _|
_| _| _|_| _|_| _|_| _| _| _| _|
Line 1,337: Line 1,904:
_|_|_| _| _|_| _|_| _| _|_|_|
_|_|_| _| _|_| _|_| _| _|_|_|
_|
_|
_|_|"""</lang>
_|_|"""</syntaxhighlight>
A more complicated example:
A more complicated example:
<lang Groovy>String.metaClass.getAsAsciiArt = {
<syntaxhighlight lang="groovy">String.metaClass.getAsAsciiArt = {
def request = "http://www.network-science.de/ascii/ascii.php?TEXT=${delegate}&x=23&y=10&FONT=block&RICH=no&FORM=left&STRE=no&WIDT=80"
def request = "http://www.network-science.de/ascii/ascii.php?TEXT=${delegate}&x=23&y=10&FONT=block&RICH=no&FORM=left&STRE=no&WIDT=80"
def html = new URL(request).text
def html = new URL(request).text
Line 1,345: Line 1,912:
}
}


println "Groovy".asAsciiArt</lang>
println "Groovy".asAsciiArt</syntaxhighlight>
{{out}}
{{out}}
<pre> _|_|_|
<pre> _|_|_|
Line 1,357: Line 1,924:
=={{header|Haskell}}==
=={{header|Haskell}}==
A simple printing of the ASCII art
A simple printing of the ASCII art
<lang Haskell>module Main where
<syntaxhighlight lang="haskell">module Main where
{-
{-
__ __ __ ___ ___
__ __ __ ___ ___
Line 1,378: Line 1,945:


main = putStrLn ascii3d
main = putStrLn ascii3d
</syntaxhighlight>
</lang>


{{out}}
{{out}}
Line 1,392: Line 1,959:
=={{header|Icon}} and {{header|Unicon}}==
=={{header|Icon}} and {{header|Unicon}}==
The following fits under the fuzzy definition of 3D ASCII and pays homage to one of the Icon Newsletter logos.
The following fits under the fuzzy definition of 3D ASCII and pays homage to one of the Icon Newsletter logos.
<lang Icon>procedure main(arglist)
<syntaxhighlight lang="icon">procedure main(arglist)
write(ExpandText(
write(ExpandText(
if !arglist == "icon" then
if !arglist == "icon" then
Line 1,425: Line 1,992:
s ? until pos(0) do
s ? until pos(0) do
writes(repl(" ",tab(many(&digits)))|tab(upto(&digits)|0))
writes(repl(" ",tab(many(&digits)))|tab(upto(&digits)|0))
end</lang>
end</syntaxhighlight>


{{out}} with "icon" as the argument:
{{out}} with "icon" as the argument:
Line 1,461: Line 2,028:
=={{header|J}}==
=={{header|J}}==


<lang j> require 'vrml.ijs' NB. Due to Andrew Nikitin
<syntaxhighlight lang="j"> require 'vrml.ijs' NB. Due to Andrew Nikitin
view 5#.^:_1]21-~a.i.'j*ez`C3\toy.G)' NB. Due to Oleg Kobchenko
view 5#.^:_1]21-~a.i.'j*ez`C3\toy.G)' NB. Due to Oleg Kobchenko
________________________
________________________
Line 1,483: Line 2,050:
\| | | |
\| | | |
\_____|_____|_____|
\_____|_____|_____|
</syntaxhighlight>
</lang>


For the VRML script, see [http://nsg.upor.net/jpage/jpage.htm Andrew Nikitin's J page] (search for VRML) and for the origin of the 3D J banner, see [http://www.jsoftware.com/pipermail/programming/2007-May/006539.html Oleg Kobchenko's post to the J Forums].
For the VRML script, see [http://nsg.upor.net/jpage/jpage.htm Andrew Nikitin's J page] (search for VRML) and for the origin of the 3D J banner, see [http://www.jsoftware.com/pipermail/programming/2007-May/006539.html Oleg Kobchenko's post to the J Forums].
Line 1,489: Line 2,056:
Here's a slimmer version:
Here's a slimmer version:


<lang J> view 8 8 8#:'"#$%&,4<DHLPTYZ[\'-&(a.&i.)' '
<syntaxhighlight lang="j"> view 8 8 8#:'"#$%&,4<DHLPTYZ[\'-&(a.&i.)' '
Line 1,525: Line 2,092:
\| |
\| |
\_____|
\_____|
</syntaxhighlight>
</lang>


Explanation: the argument says where to place the solid "blocks". Each block is described by three integers, describing position along the x, y and z axis. In other words, 1 0 0 is one position to the right of 0 0 0, while 0 1 0 is one place down and 0 0 1 is one place towards the observer. (Thus the space at the top of the "slimmer" version could have been eliminated by subtracting 2 from the middle column of integers being passed to 'view'.)
Explanation: the argument says where to place the solid "blocks". Each block is described by three integers, describing position along the x, y and z axis. In other words, 1 0 0 is one position to the right of 0 0 0, while 0 1 0 is one place down and 0 0 1 is one place towards the observer. (Thus the space at the top of the "slimmer" version could have been eliminated by subtracting 2 from the middle column of integers being passed to 'view'.)
Line 1,535: Line 2,102:
=={{header|Java}}==
=={{header|Java}}==
This was written ages ago as an exercise in obfuscation, and improved here with upper case letters. The font is "lean" from [http://en.wikipedia.org/wiki/Figlet figlet].
This was written ages ago as an exercise in obfuscation, and improved here with upper case letters. The font is "lean" from [http://en.wikipedia.org/wiki/Figlet figlet].

<lang java>public class F5{
It's not really that obfuscated. The characters in <var>z</var> are used to draw the letters. The array <var>f</var> contains one element per letter of the alphabet. Each array element is another array of 7 longs because each output letter is made of 7 lines of text. Each long value represents a sequence of 2-bit integers that are extracted by bit-twiddling and used to find the right character in <var>z</var>.
<syntaxhighlight lang="java">public class F5{
char[]z={' ',' ','_','/',};
char[]z={' ',' ','_','/',};
long[][]f={
long[][]f={
Line 1,613: Line 2,182:
System.out.print(' ');
System.out.print(' ');
System.out.println(o[i]);}}}
System.out.println(o[i]);}}}
</syntaxhighlight>
</lang>


{{out}} With no parameters:
{{out}} With no parameters:
Line 1,637: Line 2,206:
</pre>
</pre>


=={{header|jq}}==
{{works with|jq}}
'''Works with gojq, the Go implementation of jq'''

One small point of interest here is the use of string interpolation to simulate a "heredoc" string.
<syntaxhighlight lang="jq">def jq:
"\("
#
#
# # ###
# # # #
# # # #
# # # # ####
# ### #
#
")";

def banner3D:
jq | split("\n") | map( gsub("#"; "╔╗") | gsub(" "; " ") )
| [[range(length;0;-1) | " " * .], . ] | transpose[] | join("") ;

banner3D</syntaxhighlight>
{{out}}
<pre>
╔╗
╔╗
╔╗ ╔╗ ╔╗╔╗╔╗
╔╗ ╔╗ ╔╗ ╔╗
╔╗ ╔╗ ╔╗ ╔╗
╔╗ ╔╗ ╔╗ ╔╗ ╔╗╔╗╔╗╔╗
╔╗ ╔╗╔╗╔╗ ╔╗
╔╗

</pre>

=={{header|Julia}}==
{{trans|Awk}}
<syntaxhighlight lang="julia">println(replace(raw"""
xxxxx
x x
x x x
x x x x
x x x x x xxx
x x x x x x x
x x x x x x x xx
xx xx x x x x xx
""", "x" => "_/"))
</syntaxhighlight>{{output}}<pre>
_/_/_/_/_/
_/ _/
_/ _/ _/
_/ _/ _/ _/
_/ _/ _/ _/ _/ _/_/_/
_/ _/ _/ _/ _/ _/ _/
_/ _/ _/ _/ _/ _/ _/ _/_/
_/_/ _/_/ _/ _/ _/ _/ _/_/
</pre>

=={{header|Kotlin}}==
{{trans|Java}}
<syntaxhighlight lang="scala">// version 1.1

class Ascii3D(s: String) {
val z = charArrayOf(' ', ' ', '_', '/')

val f = arrayOf(
longArrayOf(87381, 87381, 87381, 87381, 87381, 87381, 87381),
longArrayOf(349525, 375733, 742837, 742837, 375733, 349525, 349525),
longArrayOf(742741, 768853, 742837, 742837, 768853, 349525, 349525),
longArrayOf(349525, 375733, 742741, 742741, 375733, 349525, 349525),
longArrayOf(349621, 375733, 742837, 742837, 375733, 349525, 349525),
longArrayOf(349525, 375637, 768949, 742741, 375733, 349525, 349525),
longArrayOf(351157, 374101, 768949, 374101, 374101, 349525, 349525),
longArrayOf(349525, 375733, 742837, 742837, 375733, 349621, 351157),
longArrayOf(742741, 768853, 742837, 742837, 742837, 349525, 349525),
longArrayOf(181, 85, 181, 181, 181, 85, 85),
longArrayOf(1461, 1365, 1461, 1461, 1461, 1461, 2901),
longArrayOf(742741, 744277, 767317, 744277, 742837, 349525, 349525),
longArrayOf(181, 181, 181, 181, 181, 85, 85),
longArrayOf(1431655765, 3149249365L, 3042661813L, 3042661813L, 3042661813L, 1431655765, 1431655765),
longArrayOf(349525, 768853, 742837, 742837, 742837, 349525, 349525),
longArrayOf(349525, 375637, 742837, 742837, 375637, 349525, 349525),
longArrayOf(349525, 768853, 742837, 742837, 768853, 742741, 742741),
longArrayOf(349525, 375733, 742837, 742837, 375733, 349621, 349621),
longArrayOf(349525, 744373, 767317, 742741, 742741, 349525, 349525),
longArrayOf(349525, 375733, 767317, 351157, 768853, 349525, 349525),
longArrayOf(374101, 768949, 374101, 374101, 351157, 349525, 349525),
longArrayOf(349525, 742837, 742837, 742837, 375733, 349525, 349525),
longArrayOf(5592405, 11883957, 11883957, 5987157, 5616981, 5592405, 5592405),
longArrayOf(366503875925L, 778827027893L, 778827027893L, 392374737749L, 368114513237L, 366503875925L, 366503875925L),
longArrayOf(349525, 742837, 375637, 742837, 742837, 349525, 349525),
longArrayOf(349525, 742837, 742837, 742837, 375733, 349621, 375637),
longArrayOf(349525, 768949, 351061, 374101, 768949, 349525, 349525),
longArrayOf(375637, 742837, 768949, 742837, 742837, 349525, 349525),
longArrayOf(768853, 742837, 768853, 742837, 768853, 349525, 349525),
longArrayOf(375733, 742741, 742741, 742741, 375733, 349525, 349525),
longArrayOf(192213, 185709, 185709, 185709, 192213, 87381, 87381),
longArrayOf(1817525, 1791317, 1817429, 1791317, 1817525, 1398101, 1398101),
longArrayOf(768949, 742741, 768853, 742741, 742741, 349525, 349525),
longArrayOf(375733, 742741, 744373, 742837, 375733, 349525, 349525),
longArrayOf(742837, 742837, 768949, 742837, 742837, 349525, 349525),
longArrayOf(48053, 23381, 23381, 23381, 48053, 21845, 21845),
longArrayOf(349621, 349621, 349621, 742837, 375637, 349525, 349525),
longArrayOf(742837, 744277, 767317, 744277, 742837, 349525, 349525),
longArrayOf(742741, 742741, 742741, 742741, 768949, 349525, 349525),
longArrayOf(11883957, 12278709, 11908533, 11883957, 11883957, 5592405, 5592405),
longArrayOf(11883957, 12277173, 11908533, 11885493, 11883957, 5592405, 5592405),
longArrayOf(375637, 742837, 742837, 742837, 375637, 349525, 349525),
longArrayOf(768853, 742837, 768853, 742741, 742741, 349525, 349525),
longArrayOf(6010197, 11885397, 11909973, 11885397, 6010293, 5592405, 5592405),
longArrayOf(768853, 742837, 768853, 742837, 742837, 349525, 349525),
longArrayOf(375733, 742741, 375637, 349621, 768853, 349525, 349525),
longArrayOf(12303285, 5616981, 5616981, 5616981, 5616981, 5592405, 5592405),
longArrayOf(742837, 742837, 742837, 742837, 375637, 349525, 349525),
longArrayOf(11883957, 11883957, 11883957, 5987157, 5616981, 5592405, 5592405),
longArrayOf(3042268597L, 3042268597L, 3042661813L, 1532713813, 1437971797, 1431655765, 1431655765),
longArrayOf(11883957, 5987157, 5616981, 5987157, 11883957, 5592405, 5592405),
longArrayOf(11883957, 5987157, 5616981, 5616981, 5616981, 5592405, 5592405),
longArrayOf(12303285, 5593941, 5616981, 5985621, 12303285, 5592405, 5592405)
)

init {
val o = Array(7) { StringBuilder() }
for (i in 0 until s.length) {
var c = s[i].toInt()
if (c in 65..90) {
c -= 39
} else if (c in 97..122) {
c -= 97
} else {
c = -1
}
val d = f[++c]
for (j in 0 until 7) {
val b = StringBuilder()
var v = d[j]
while (v > 0) {
b.append(z[(v and 3).toInt()])
v = v shr 2
}
o[j].append(b.reverse().toString())
}
}
for (i in 0 until 7) {
for (j in 0 until 7 - i) print(' ')
println(o[i])
}
}
}

fun main(args: Array<String>) {
Ascii3D("KOTLIN")
Ascii3D("with thanks")
Ascii3D("to the author")
Ascii3D("of the")
Ascii3D("Java entry")
}</syntaxhighlight>

{{out}}
<pre>
_/ _/ _/_/ _/_/_/_/_/ _/ _/_/_/ _/ _/
_/ _/ _/ _/ _/ _/ _/ _/_/ _/
_/_/ _/ _/ _/ _/ _/ _/ _/ _/
_/ _/ _/ _/ _/ _/ _/ _/ _/_/
_/ _/ _/_/ _/ _/_/_/_/ _/_/_/ _/ _/


_/ _/ _/ _/ _/ _/
_/ _/ _/ _/_/_/_/ _/_/_/ _/_/_/_/ _/_/_/ _/_/_/ _/_/_/ _/ _/ _/_/_/
_/ _/ _/ _/ _/ _/ _/ _/ _/ _/ _/ _/ _/ _/ _/_/ _/_/
_/ _/ _/ _/ _/ _/ _/ _/ _/ _/ _/ _/ _/ _/ _/ _/ _/ _/_/
_/ _/ _/ _/_/ _/ _/ _/_/ _/ _/ _/_/_/ _/ _/ _/ _/ _/_/_/


_/ _/ _/ _/ _/
_/_/_/_/ _/_/ _/_/_/_/ _/_/_/ _/_/ _/_/_/ _/ _/ _/_/_/_/ _/_/_/ _/_/ _/ _/_/
_/ _/ _/ _/ _/ _/ _/_/_/_/ _/ _/ _/ _/ _/ _/ _/ _/ _/ _/_/
_/ _/ _/ _/ _/ _/ _/ _/ _/ _/ _/ _/ _/ _/ _/ _/ _/
_/_/ _/_/ _/_/ _/ _/ _/_/_/ _/_/_/ _/_/_/ _/_/ _/ _/ _/_/ _/


_/_/ _/ _/
_/_/ _/ _/_/_/_/ _/_/_/ _/_/
_/ _/ _/_/_/_/ _/ _/ _/ _/_/_/_/
_/ _/ _/ _/ _/ _/ _/
_/_/ _/ _/_/ _/ _/ _/_/_/


_/ _/
_/ _/_/_/ _/ _/ _/_/_/ _/_/ _/_/_/ _/_/_/_/ _/ _/_/ _/ _/
_/ _/ _/ _/ _/ _/ _/ _/_/_/_/ _/ _/ _/ _/_/ _/ _/
_/ _/ _/ _/ _/ _/ _/ _/ _/ _/ _/ _/ _/ _/ _/
_/_/ _/_/_/ _/ _/_/_/ _/_/_/ _/ _/ _/_/ _/ _/_/_/
_/
_/_/
</pre>


=={{header|Lasso}}==
=={{header|Lasso}}==
<lang Lasso>local(lasso = "
<syntaxhighlight lang="lasso">local(lasso = "
---------------------------------------------------------------
---------------------------------------------------------------
| ,--, |
| ,--, |
Line 1,658: Line 2,423:
")
")


stdoutnl(#lasso)</lang>
stdoutnl(#lasso)</syntaxhighlight>
<pre>---------------------------------------------------------------
<pre>---------------------------------------------------------------
| ,--, |
| ,--, |
Line 1,677: Line 2,442:
</pre>
</pre>


=={{header|Mathematica}}==
=={{header|Lua}}==
<syntaxhighlight lang="lua">io.write(" /$$\n")
io.write("| $$\n")
io.write("| $$ /$$ /$$ /$$$$$$\n")
io.write("| $$ | $$ | $$ |____ $$\n")
io.write("| $$ | $$ | $$ /$$$$$$$\n")
io.write("| $$ | $$ | $$ /$$__ $$\n")
io.write("| $$$$$$$$| $$$$$$/| $$$$$$$\n")
io.write("|________/ \______/ \_______/\n")</syntaxhighlight>
{{out}}
<pre> /$$
| $$
| $$ /$$ /$$ /$$$$$$
| $$ | $$ | $$ |____ $$
| $$ | $$ | $$ /$$$$$$$
| $$ | $$ | $$ /$$__ $$
| $$$$$$$$| $$$$$$/| $$$$$$$
|________/ ______/ _______/</pre>
Alternate:
<syntaxhighlight lang="lua">print[[
__
/\ \
\ \ \ __ __ ____
\ \ \ /\ \/\ \ / __ \
\ \ \___\ \ \_\ \/\ \_\ \_
\ \____\\ \____/\ \___/\_\
\/____/ \/___/ \/__/\/_/]]</syntaxhighlight>
{{out}}
<pre> __
/\ \
\ \ \ __ __ ____
\ \ \ /\ \/\ \ / __ \
\ \ \___\ \ \_\ \/\ \_\ \_
\ \____\\ \____/\ \___/\_\
\/____/ \/___/ \/__/\/_/</pre>

=={{header|Mathematica}}/{{header|Wolfram Language}}==
No hardcoding at all!
No hardcoding at all!
<lang Mathematica>locs = Position[
<syntaxhighlight lang="mathematica">locs = Position[
ImageData[Binarize[Rasterize["Mathematica", ImageSize -> 150]]], 0];
ImageData[Binarize[Rasterize["Mathematica", ImageSize -> 150]]], 0];
Print[StringRiffle[
Print[StringRiffle[
Line 1,687: Line 2,488:
ConstantArray[
ConstantArray[
" ", {Max[locs[[All, 1]]] + 1, Max[locs[[All, 2]]] + 1}],
" ", {Max[locs[[All, 1]]] + 1, Max[locs[[All, 2]]] + 1}],
locs -> "\\"], Map[# + 1 &, locs, {2}] -> "#"], "\n"]];</lang>
locs -> "\\"], Map[# + 1 &, locs, {2}] -> "#"], "\n"]];</syntaxhighlight>
{{output}}
{{output}}
<pre>
<pre>
Line 1,709: Line 2,510:
\\#\\ \\\##\ #\\\####\ ##\\\\## \\## \\\#\ ##\\\\\###\\## \# \#\ #\\\\####\ ##\\\## \\\\\\#\\\ ##\\\### #\\\####\
\\#\\ \\\##\ #\\\####\ ##\\\\## \\## \\\#\ ##\\\\\###\\## \# \#\ #\\\\####\ ##\\\## \\\\\\#\\\ ##\\\### #\\\####\
##### ###### #### #### ###### #### ##### ####### #### ## ### ##### #### ##### ########## ##### #### ####</pre>
##### ###### #### #### ###### #### ##### ####### #### ## ### ##### #### ##### ########## ##### #### ####</pre>

=={{header|MiniScript}}==
Nothing fancy here, but in keeping with MiniScript's "clear and simple" ethos:
<syntaxhighlight lang="miniscript">data = [
" ______ _____ _________",
"|\ \/ \ ___ ________ ___|\ _____\ ________ ________ ___ ________ _________ ",
"\ \ _ \ _ \|\ \|\ ___ \|\ \ \ \____||\ ____\|\ ____\|\ \|\ __ \|\___ ___\ ",
" \ \ \\\__\ \ \ \ \ \ \\ \ \ \ \ \_____ \ \ \___|\ \ \___|\ \ \ \ \|\ \|___ \ \_| ",
" \ \ \\|__| \ \ \ \ \ \\ \ \ \ \|____|\ \ \ \ \ \ \ \ \ \ \ ____\ \ \ \ ",
" \ \ \ \ \ \ \ \ \ \\ \ \ \ \____\_\ \ \ \____\ \ \ \ \ \ \ \___| \ \ \ ",
" \ \__\ \ \__\ \__\ \__\\ \__\ \__\_________\ \_______\ \__\ \ \__\ \__\ \ \__\",
" \|__| \|__|\|__|\|__| \|__|\|__||________|\|_______|\|__| \|__|\|__| \|__|"]

for line in data
print line
end for</syntaxhighlight>
{{out}}
<pre> ______ _____ _________
|\ \/ \ ___ ________ ___|\ _____\ ________ ________ ___ ________ _________
\ \ _ \ _ \|\ \|\ ___ \|\ \ \ \____||\ ____\|\ ____\|\ \|\ __ \|\___ ___\
\ \ \\\__\ \ \ \ \ \ \\ \ \ \ \ \_____ \ \ \___|\ \ \___|\ \ \ \ \|\ \|___ \ \_|
\ \ \\|__| \ \ \ \ \ \\ \ \ \ \|____|\ \ \ \ \ \ \ \ \ \ \ ____\ \ \ \
\ \ \ \ \ \ \ \ \ \\ \ \ \ \____\_\ \ \ \____\ \ \ \ \ \ \ \___| \ \ \
\ \__\ \ \__\ \__\ \__\\ \__\ \__\_________\ \_______\ \__\ \ \__\ \__\ \ \__\
\|__| \|__|\|__|\|__| \|__|\|__||________|\|_______|\|__| \|__|\|__| \|__|</pre>

=={{header|Modula-2}}==
<syntaxhighlight lang="modula2">MODULE Art;
FROM Terminal IMPORT WriteString,WriteLn,ReadChar;

BEGIN
(* 3D, but does not fit in the terminal window *)
(*
WriteString("_____ ______ ________ ________ ___ ___ ___ ________ _______");
WriteLn;
WriteString("|\ _ \ _ \|\ __ \|\ ___ \|\ \|\ \|\ \ |\ __ \ / ___ \");
WriteLn;
WriteString("\ \ \\\__\ \ \ \ \|\ \ \ \_|\ \ \ \\\ \ \ \ \ \ \|\ \ ____________ /__/|_/ /|");
WriteLn;
WriteString(" \ \ \\|__| \ \ \ \\\ \ \ \ \\ \ \ \\\ \ \ \ \ \ __ \|\____________\__|// / /");
WriteLn;
WriteString(" \ \ \ \ \ \ \ \\\ \ \ \_\\ \ \ \\\ \ \ \____\ \ \ \ \|____________| / /_/__");
WriteLn;
WriteString(" \ \__\ \ \__\ \_______\ \_______\ \_______\ \_______\ \__\ \__\ |\________\");
WriteLn;
WriteString(" \|__| \|__|\|_______|\|_______|\|_______|\|_______|\|__|\|__| \|_______|");
WriteLn;
*)

(* Not 3D, but fits in the terminal window *)
WriteString(" __ __ _ _ ___");
WriteLn;
WriteString(" | \/ | | | | | |__ \");
WriteLn;
WriteString(" | \ / | ___ __| |_ _| | __ _ ______ ) |");
WriteLn;
WriteString(" | |\/| |/ _ \ / _` | | | | |/ _` |______/ /");
WriteLn;
WriteString(" | | | | (_) | (_| | |_| | | (_| | / /_");
WriteLn;
WriteString(" |_| |_|\___/ \__,_|\__,_|_|\__,_| |____|");
WriteLn;

ReadChar
END Art.
</syntaxhighlight>

=={{header|Nanoquery}}==
<syntaxhighlight lang="nanoquery">println " ________ ________ ________ ________ ________ ___ ___ _______ ________ ___ ___ "
println "|\\ ___ \\|\\ __ \\|\\ ___ \\|\\ __ \\|\\ __ \\|\\ \\|\\ \\|\\ ___ \\ |\\ __ \\ |\\ \\ / /| "
println "\\ \\ \\\\ \\ \\ \\ \\|\\ \\ \\ \\\\ \\ \\ \\ \\|\\ \\ \\ \\|\\ \\ \\ \\\\\\ \\ \\ __/|\\ \\ \\|\\ \\ \\ \\ \\/ / / "
println " \\ \\ \\\\ \\ \\ \\ __ \\ \\ \\\\ \\ \\ \\ \\\\\\ \\ \\ \\\\\\ \\ \\ \\\\\\ \\ \\ \\_|/_\\ \\ _ _\\ \\ \\ / / "
println " \\ \\ \\\\ \\ \\ \\ \\ \\ \\ \\ \\\\ \\ \\ \\ \\\\\\ \\ \\ \\\\\\ \\ \\ \\\\\\ \\ \\ \\_|\\ \\ \\ \\\\ \\| \\/ / / "
println " \\ \\__\\\\ \\__\\ \\__\\ \\__\\ \\__\\\\ \\__\\ \\_______\\ \\_____ \\ \\_______\\ \\_______\\ \\__\\\\ _\\ __/ / / "
println " \\|__| \\|__|\\|__|\\|__|\\|__| \\|__|\\|_______|\\|___| \\__\\|_______|\\|_______|\\|__|\\|__|\\___/ / "
println " \\|__| \\|___|/ "</syntaxhighlight>
{{out}}
<pre> ________ ________ ________ ________ ________ ___ ___ _______ ________ ___ ___
|\ ___ \|\ __ \|\ ___ \|\ __ \|\ __ \|\ \|\ \|\ ___ \ |\ __ \ |\ \ / /|
\ \ \\ \ \ \ \|\ \ \ \\ \ \ \ \|\ \ \ \|\ \ \ \\\ \ \ __/|\ \ \|\ \ \ \ \/ / /
\ \ \\ \ \ \ __ \ \ \\ \ \ \ \\\ \ \ \\\ \ \ \\\ \ \ \_|/_\ \ _ _\ \ \ / /
\ \ \\ \ \ \ \ \ \ \ \\ \ \ \ \\\ \ \ \\\ \ \ \\\ \ \ \_|\ \ \ \\ \| \/ / /
\ \__\\ \__\ \__\ \__\ \__\\ \__\ \_______\ \_____ \ \_______\ \_______\ \__\\ _\ __/ / /
\|__| \|__|\|__|\|__|\|__| \|__|\|_______|\|___| \__\|_______|\|_______|\|__|\|__|\___/ /
\|__| \|___|/</pre>


=={{header|NetRexx}}==
=={{header|NetRexx}}==
Based on an idea found in the [[#Scala|Scala]] version.
Based on an idea found in the [[#Scala|Scala]] version.
<lang NetRexx>/* NetRexx */
<syntaxhighlight lang="netrexx">/* NetRexx */
options replace format comments java crossref symbols nobinary
options replace format comments java crossref symbols nobinary


Line 1,777: Line 2,663:
method isFalse public constant binary returns boolean
method isFalse public constant binary returns boolean
return \isTrue()
return \isTrue()
</syntaxhighlight>
</lang>
{{out}}
{{out}}
<pre>
<pre>
Line 1,798: Line 2,684:
=={{header|Nim}}==
=={{header|Nim}}==
{{trans|Python}}
{{trans|Python}}
<lang nim>import strutils
<syntaxhighlight lang="nim">import strutils


const nim = """
const nim = """
# # ##### # # #### #### ####
# # ##### # #
## # # ## ## # # # # # #
## # # ## ##
# # # # # ## # # # # # # #
# # # # # ## #
# # # # # # #### # # # #
# # # # # #
# ## # # # # # # # # #
# ## # # #
# # ##### # # # # #### ####"""
# # ##### # #
"""
let lines = nim.dedent.multiReplace(("#", "<<<"), (" ", " "), ("< ", "<>"), ("<\n", "<>\n")).splitLines
for i, line in lines:
echo spaces(lines.len - i), line</syntaxhighlight>
{{out}}
<pre> <<< <<< <<<<<<<<<<<<<<< <<< <<<
<<<<<< <<< <<< <<<<<< <<<<<<
<<< <<< <<< <<< <<< <<<<<< <<<
<<< <<< <<< <<< <<< <<<
<<< <<<<<< <<< <<< <<<
<<< <<< <<<<<<<<<<<<<<< <<< <<<</pre>


=={{header|OCaml}}==
let lines = nim.replace("#", "<<<").replace(" ", "X").replace("X", " ").replace("\n", " Y").replace("< ", "<>").split('Y')
<syntaxhighlight lang="ocaml">
for i, l in lines:
print_string "
echo repeatChar((lines.len - i) * 3), l</lang>
_|_|_| _|_|_| _|_| _|_| _|_| _|
_| _| _| _| _| _| _| _| _| _|
_| _| _| _|_|_| _| _| _| _| _|
_| _| _| _| _| _| _| _|
_|_|_| _|_|_| _| _| _| _| _|_|_|_|_|
"
</syntaxhighlight>
{{out}}
{{out}}
<pre>
<pre> <<<> <<<> <<<<<<<<<<<<<<<> <<<> <<<> <<<<<<<<<<<<> <<<<<<<<<<<<> <<<<<<<<<<<<>

<<<<<<> <<<> <<<> <<<<<<> <<<<<<> <<<> <<<> <<<> <<<> <<<> <<<>
<<<> <<<> <<<> <<<> <<<> <<<<<<> <<<> <<<> <<<> <<<> <<<> <<<> <<<>
_|_|_| _|_|_| _|_| _|_| _|_| _|
<<<> <<<> <<<> <<<> <<<> <<<> <<<<<<<<<<<<> <<<> <<<> <<<> <<<>
_| _| _| _| _| _| _| _| _| _|
<<<> <<<<<<> <<<> <<<> <<<> <<<> <<<> <<<> <<<> <<<> <<<>
_| _| _| _|_|_| _| _| _| _| _|
<<<> <<<> <<<<<<<<<<<<<<<> <<<> <<<> <<<> <<<> <<<<<<<<<<<<> <<<<<<<<<<<<</pre>
_| _| _| _| _| _| _| _|
_|_|_| _|_|_| _| _| _| _| _|_|_|_|_|
</pre>


=={{header|Pascal}}==
=={{header|Pascal}}==
<lang pascal>
<syntaxhighlight lang="pascal">
program WritePascal;
program WritePascal;


Line 1,846: Line 2,752:
end;
end;
end.
end.
</syntaxhighlight>
</lang>
Need 64-Bit Integer for this solution.
Need 64-Bit Integer for this solution.
My goal was to do a straight-forward solution, (Just two nested loops, no conditional code).
My goal was to do a straight-forward solution, (Just two nested loops, no conditional code).
Line 1,862: Line 2,768:


</pre>
</pre>

=={{header|Perl}}==
=={{header|Perl}}==
<lang perl>#!/usr/bin/perl
<syntaxhighlight lang="perl">#!/usr/bin/perl
use strict;
use strict;
use warnings;
use warnings;
Line 1,873: Line 2,780:
) {
) {
print $tuple->[0] x $tuple->[1];
print $tuple->[0] x $tuple->[1];
}</lang>
}</syntaxhighlight>
{{out}}
{{out}}
<pre> _ \ |
<pre> _ \ |
Line 1,880: Line 2,787:
_| \___|_| _|</pre>
_| \___|_| _|</pre>
Font taken from http://www.network-science.de/ascii/.
Font taken from http://www.network-science.de/ascii/.

=={{header|Perl 6}}==
Produces a good old-fashioned stereogram, meant to be looked at by focusing beyond the screen, not by crossing your eyes. If you can't get it to converge, try shrinking the font size till the images are closer together than your eyes. Also helps to be old enough to have progressive lenses, so you can look through the reading part of your glasses. Or borrow glasses from someone who's farsighted. <tt>:-)</tt>
<lang>my $text = q:to/END/;

@@@@@ @@
@ @ @ @@@
@ @ @ @@
@ @ @@@ @ @@ @ @@
@@@@@ @ @ @@ @ @ @@@@@
@ @@@@@ @ @ @@ @@
@ @ @ @ @@ @@
@ @@@ @ @@ @@@@

END

say '' for ^5;
for $text.lines -> $_ is copy {
my $/;
my @chars = ｢-+ ., ;: '"｣.comb.pick(*) xx *;
s:g [' '] = @chars.shift;
print " $_ ";
s:g [('@'+)(.)] = @chars.shift ~ $0;
.say;
}
say '' for ^5;</lang>
{{out}}
<small><pre>




";,' :-+ . ,. ; -:+"',';-. : " + ";,' :-+ . ,. ; -:+"',';-. : " +
:@@@@@ ,'+".-; ;-+,@@"' :. ;. " :'@@@@@ ,'+".-; ;-+,,@@' :. ;. "
"@-. @ ';,+:- +: ,;@'". +@@@, "- " @. .@';,+:- +: ,;:@". +;@@@ "-
'@,- ;@ "+: .+ -',:" @; . @@; -" , ':@- ;'@"+: .+ -',:" .@ . +@@ -" ,
;@ +, @"-@@@' :@.@@ @-,:.@@+ ;'": ; @+, .@-'@@@ : @;@@ @,:.+@@ ;'":
@@@@@+-@':.@, @@" @;@ +":@@@@@', ;@@@@@--@:. @ .@@ :@ @+": @@@@@,
@;-+, .@@@@@ :@"'+' @"-,:@@; @@. +@-+, .,@@@@@::@'+' @-,: @@ "@@
:@ . "- @,;+'; @" .-'@ +:,@@ ;@@'+ :-@. "- ,@;+'; "@ .-' @+:, @@;:@@+
+@'"., ; @@@ -:@;' "@@-+.:@@@@, +:@"., ; "@@@-:;@' ".@@+.: @@@@
;.:+"-,' +:'; -," .+:" ;-.,' . ;.:+"-,' +:'; -," .+:" ;-.,' .





</pre></small>


=={{header|Phix}}==
=={{header|Phix}}==
<!--<syntaxhighlight lang="phix">(phixonline)-->
<lang Phix>constant s =
<span style="color: #008080;">constant</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"""
"------*** * \n"&
"-----* * * \n"&
------*** *
"----* * * * \n"&
-----* * *
"---*** * \n"&
----* * * *
"--* *** * * * \n"&
---*** *
"-* * * * * \n"&
--* *** * * *
"* * * * * * \n"
-* * * * *
* * * * * *
puts(1,substitute(substitute(s,"*","_/")," "," "))
</lang>
"""</span>
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">substitute_all</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"* "</span><span style="color: #0000FF;">,{</span><span style="color: #008000;">"_/"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">" "</span><span style="color: #0000FF;">}))</span>
<!--</syntaxhighlight>-->
{{out}}
{{out}}
<pre>
<pre>
Line 1,950: Line 2,811:
_/ _/ _/ _/ _/ _/
_/ _/ _/ _/ _/ _/
</pre>
</pre>
===obfuscated===

For those of you who like this sort of thing, same output
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #008080;">constant</span> <span style="color: #000000;">q</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">0(30)10C</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0(31)176</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0(32)2A4</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0(33)6N3</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0(34)7GP</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0(35)DWF</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0(36)QC4</span><span style="color: #0000FF;">}</span>
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">substitute_all</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">join</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"%16b"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">7</span><span style="color: #0000FF;">),</span><span style="color: #008000;">"\n"</span><span style="color: #0000FF;">),</span><span style="color: #000000;">q</span><span style="color: #0000FF;">),</span><span style="color: #008000;">" 10"</span><span style="color: #0000FF;">,{</span><span style="color: #008000;">"-"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"_/"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">" "</span><span style="color: #0000FF;">})&</span><span style="color: #008000;">"\n"</span><span style="color: #0000FF;">)</span>
<!--</syntaxhighlight>-->
===another version===
Inspired by Ruby
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"""
__ ________
/_/\ / ______ \
\ \ \/ /\____/ /\ __
\ \ \/ / / / //_/\
\ \ \/___/ / / \_\/_ __
/\ \______/ / /_/\/ /\
/ /\ ____ \ \ \ \ \/ /
/ / /\ \ \ \ \ \ \_\ /
/ / / \ \ \ \ \ \ / / \
/_/ / \ \ \ \ \ \ /_/ /\ \
\_\/ \_\/ \_\/ \_\/\_\/
"""</span><span style="color: #0000FF;">)</span>
<span style="color: #000080;font-style:italic;">-- or if you prefer something a little more cryptic (same output):</span>
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">" __ ________\n /_/\\ / ______ \\\n \\ \\ \\/ /\\____/ /\\ __\n "</span><span style="color: #0000FF;">&</span>
<span style="color: #008000;">"\\ \\ \\/ / / / //_/\\\n \\ \\ \\/___/ / / \\_\\/_ __\n /\\ \\__"</span><span style="color: #0000FF;">&</span>
<span style="color: #008000;">"____/ / /_/\\/ /\\\n / /\\ ____ \\ \\ \\ \\ \\/ /\n / / /\\ \\ "</span><span style="color: #0000FF;">&</span>
<span style="color: #008000;">"\\ \\ \\ \\ \\_\\ /\n / / / \\ \\ \\ \\ \\ \\ / / \\\n/_/ / \\"</span><span style="color: #0000FF;">&</span>
<span style="color: #008000;">" \\ \\ \\ \\ \\ /_/ /\\ \\\n\\_\\/ \\_\\/ \\_\\/ \\_\\/\\_\\/\n"</span><span style="color: #0000FF;">)</span>
<!--</syntaxhighlight>-->


=={{header|PicoLisp}}==
=={{header|PicoLisp}}==
{{Trans|Tcl}}
{{Trans|Tcl}}
<lang PicoLisp>(de Lst
<syntaxhighlight lang="picolisp">(de Lst
"***** * "
"***** * "
"* * * * * "
"* * * * * "
Line 1,988: Line 2,877:
(maplist '((X) (transform X "/" "\\")) (cdr Lst)) )
(maplist '((X) (transform X "/" "\\")) (cdr Lst)) )


(bye)</lang>
(bye)</syntaxhighlight>


{{out}}
{{out}}
Line 2,001: Line 2,890:
///\/ ///\/ ////////////\ ////////////\/ ////////////\ ///\/ ////////////\/ ///\/
///\/ ///\/ ////////////\ ////////////\/ ////////////\ ///\/ ////////////\/ ///\/
\\\/ \\\/ \\\\\\\\\\\\/ \\\\\\\\\\\\/ \\\\\\\\\\\\/ \\\/ \\\\\\\\\\\\/ \\\/
\\\/ \\\/ \\\\\\\\\\\\/ \\\\\\\\\\\\/ \\\\\\\\\\\\/ \\\/ \\\\\\\\\\\\/ \\\/
</pre>

=={{header|Plain English}}==
<syntaxhighlight lang="text">
To run:
Start up.
Print the language name in 3D ASCII.
Wait for the escape key.
Shut down.

To print the language name in 3D ASCII:
Write "Osmosian Order of" to the console.
Write " ____ _ _" to the console.
Write "/___ \ /_/| /_/|" to the console.
Write "| \ \| || ____ |_|/ _____" to the console.
Write "| |\ \|| || /___/| _ /____/\" to the console.
Write "| | | || || / ||/_/|| \ \" to the console.
Write "| |/ / | ||/ /| ||| ||| |\ \/" to the console.
Write "| __/ | ||| | | ||| ||| | | ||" to the console.
Write "| || | ||\ \| ||| ||| | | ||" to the console.
Write "|_|/ |_|/ \____|/|_|/|_| |_|/" to the console.
Write " ______ _ _ _" to the console.
Write "/_____/| /_/|/_/| /_/|" to the console.
Write "| ___|/ _____ ____ | |||_|/ _______| ||__" to the console.
Write "| ||___ /____/\ /___/|| || _ /______/| /__/\" to the console.
Write "| |/__/|| \ \ / ||| ||/_/|/ ___|/| \ \" to the console.
Write "| ___|/| |\ \// /| ||| ||| ||| |___/\| |\ \/" to the console.
Write "| ||___ | | | ||| | | ||| ||| ||\____ \|| | | ||" to the console.
Write "| |/__/|| | | ||\ \| ||| ||| ||____| || | | ||" to the console.
Write "|_____|/|_| |_|/ \__ |||_|/|_|/|_____/ |_| |_|/" to the console.
Write " ___| ||" to the console.
Write " /___/ //" to the console.
Write " |____//" to the console.
Write "Programmers" to the console.
</syntaxhighlight>
{{out}}
<pre>
Osmosian Order of
____ _ _
/___ \ /_/| /_/|
| \ \| || ____ |_|/ _____
| |\ \|| || /___/| _ /____/\
| | | || || / ||/_/|| \ \
| |/ / | ||/ /| ||| ||| |\ \/
| __/ | ||| | | ||| ||| | | ||
| || | ||\ \| ||| ||| | | ||
|_|/ |_|/ \____|/|_|/|_| |_|/
______ _ _ _
/_____/| /_/|/_/| /_/|
| ___|/ _____ ____ | |||_|/ _______| ||__
| ||___ /____/\ /___/|| || _ /______/| /__/\
| |/__/|| \ \ / ||| ||/_/|/ ___|/| \ \
| ___|/| |\ \// /| ||| ||| ||| |___/\| |\ \/
| ||___ | | | ||| | | ||| ||| ||\____ \|| | | ||
| |/__/|| | | ||\ \| ||| ||| ||____| || | | ||
|_____|/|_| |_|/ \__ |||_|/|_|/|_____/ |_| |_|/
___| ||
/___/ //
|____//
Programmers
</pre>
</pre>


=={{header|PureBasic}}==
=={{header|PureBasic}}==
<lang purebasic>If OpenConsole()
<syntaxhighlight lang="purebasic">If OpenConsole()
PrintN(" ////\ ////\ ////| ")
PrintN(" ////\ ////\ ////| ")
PrintN(" //// \ __ //// \ __ |XX|_/ ")
PrintN(" //// \ __ //// \ __ |XX|_/ ")
Line 2,021: Line 2,970:
Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()
Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()
CloseConsole()
CloseConsole()
EndIf</lang>
EndIf</syntaxhighlight>
Sample output:
Sample output:
<pre> ////\ ////\ ////|
<pre> ////\ ////\ ////|
Line 2,039: Line 2,988:


=={{header|Python}}==
=={{header|Python}}==
Again based on the Scala type idea of 'fleshing out' a 2D banner version.
<b>Implementation 1:</b> based on the Scala type idea of 'fleshing out' a 2D banner version.
<lang python>py = '''\
<syntaxhighlight lang="python">py = '''\
##### # # ##### # # #### # #
#### # # ##### # # ### # #
# # # # # # # # # ## #
# # # # # # # # # ## #
# # # # ###### # # # # #
#### # # ##### # # # # #
##### # # # # # # # # #
# # # # # # # # ##
# # # # # # # # ##
# # # # # ### # #'''

# # # # # #### # #
lines = py.replace('#', '<<<').replace(' ','X') \
'''
.replace('X', ' ').replace('\n', ' Y') \
.replace('< ', '<>').split('Y')


lines = py.replace('#', '<<<').replace(' ','X').replace('X', ' ').replace('\n', ' Y').replace('< ', '<>').split('Y')
for i, l in enumerate(lines):
for i, l in enumerate(lines):
print( ' ' * (len(lines) - i) + l)</lang>
print(' ' * (len(lines) - i) + l)</syntaxhighlight>


{{out}}
{{out}}
<pre style="overflow-x: auto; white-space: pre;"> <<<<<<<<<<<<> <<<> <<<> <<<<<<<<<<<<<<<> <<<> <<<> <<<<<<<<<> <<<> <<<>
<pre>
<<<<<<<<<<<<<<<> <<<> <<<> <<<<<<<<<<<<<<<> <<<> <<<> <<<<<<<<<<<<> <<<> <<<>
<<<> <<<> <<<> <<<> <<<> <<<> <<<> <<<> <<<> <<<<<<> <<<>
<<<> <<<> <<<> <<<> <<<> <<<> <<<> <<<> <<<> <<<<<<> <<<>
<<<<<<<<<<<<> <<<> <<<> <<<<<<<<<<<<<<<> <<<> <<<> <<<> <<<> <<<>
<<<> <<<> <<<> <<<> <<<<<<<<<<<<<<<<<<> <<<> <<<> <<<> <<<> <<<>
<<<> <<<> <<<> <<<> <<<> <<<> <<<> <<<> <<<<<<>
<<<<<<<<<<<<<<<> <<<> <<<> <<<> <<<> <<<> <<<> <<<> <<<> <<<>
<<<> <<<> <<<> <<<> <<<> <<<<<<<<<> <<<> <<<</pre>
<<<> <<<> <<<> <<<> <<<> <<<> <<<> <<<> <<<<<<>
<<<> <<<> <<<> <<<> <<<> <<<<<<<<<<<<> <<<> <<<>
</pre>


<b>Implementation 2:</b>
An other implementation:
<syntaxhighlight lang="python">charWidth = 10
{{lines too long|Python|name 'table' should be split at least.}}
charHeight = 8
<lang python>
l = 20
h = 11


# char table is split into sets to prevent very long lines...
table = [
charSet1 = [
""" .----------------. .----------------. .----------------. .----------------. .----------------. .----------------. .----------------. .----------------. .----------------. .----------------. .----------------. .----------------. .----------------. .-----------------. .----------------. .----------------. .----------------. .----------------. .----------------. .----------------. .----------------. .----------------. .----------------. .----------------. .----------------. .----------------. .----------------. .----------------. """,
" ###### /####### ###### /###### /######## /######## ###### /## /##",
"""| .--------------. || .--------------. || .--------------. || .--------------. || .--------------. || .--------------. || .--------------. || .--------------. || .--------------. || .--------------. || .--------------. || .--------------. || .--------------. || .--------------. || .--------------. || .--------------. || .--------------. || .--------------. || .--------------. || .--------------. || .--------------. || .--------------. || .--------------. || .--------------. || .--------------. || .--------------. || .--------------. || .--------------. |""",
" /##__ ##| ##__ ## /##__ ##| ##__ ## | ##_____/| ##_____/ /##__ ##| ## | ##",
"""| | __ | || | ______ | || | ______ | || | ________ | || | _________ | || | _________ | || | ______ | || | ____ ____ | || | _____ | || | _____ | || | ___ ____ | || | _____ | || | ____ ____ | || | ____ _____ | || | ____ | || | ______ | || | ___ | || | _______ | || | _______ | || | _________ | || | _____ _____ | || | ____ ____ | || | _____ _____ | || | ____ ____ | || | ____ ____ | || | ________ | || | ______ | || | | |""",
"| ## | ##| ## | ##| ## \__/| ## \ ##| ## | ## | ## \__/| ## | ##",
"""| | / \ | || | |_ _ \ | || | .' ___ | | || | |_ ___ `. | || | |_ ___ | | || | |_ ___ | | || | .' ___ | | || | |_ || _| | || | |_ _| | || | |_ _| | || | |_ ||_ _| | || | |_ _| | || ||_ \ / _|| || ||_ \|_ _| | || | .' `. | || | |_ __ \ | || | .' '. | || | |_ __ \ | || | / ___ | | || | | _ _ | | || ||_ _||_ _|| || ||_ _| |_ _| | || ||_ _||_ _|| || | |_ _||_ _| | || | |_ _||_ _| | || | | __ _| | || | / _ __ `. | || | | |""",
"| ########| ####### | ## | ## | ##| ########| ########| ## #####| ########",
"""| | / /\ \ | || | | |_) | | || | / .' \_| | || | | | `. \ | || | | |_ \_| | || | | |_ \_| | || | / .' \_| | || | | |__| | | || | | | | || | | | | || | | |_/ / | || | | | | || | | \/ | | || | | \ | | | || | / .--. \ | || | | |__) | | || | / .-. \ | || | | |__) | | || | | (__ \_| | || | |_/ | | \_| | || | | | | | | || | \ \ / / | || | | | /\ | | | || | \ \ / / | || | \ \ / / | || | |_/ / / | || | |_/____) | | || | | |""",
"| ##__ ##| ##__ ##| ## | ## | ##| ##_____/| ##_____/| ##|_ ##| ##__ ##",
"""| | / ____ \ | || | | __'. | || | | | | || | | | | | | || | | _| _ | || | | _| | || | | | ____ | || | | __ | | || | | | | || | _ | | | || | | __'. | || | | | _ | || | | |\ /| | | || | | |\ \| | | || | | | | | | || | | ___/ | || | | | | | | || | | __ / | || | '.___`-. | || | | | | || | | ' ' | | || | \ \ / / | || | | |/ \| | | || | > `' < | || | \ \/ / | || | .'.' _ | || | / ___.' | || | | |""",
"| ## | ##| ## | ##| ## /##| ## /##/| ## | ## | ## | ##| ## | ##",
"""| | _/ / \ \_ | || | _| |__) | | || | \ `.___.'\ | || | _| |___.' / | || | _| |___/ | | || | _| |_ | || | \ `.___] _| | || | _| | | |_ | || | _| |_ | || | | |_' | | || | _| | \ \_ | || | _| |__/ | | || | _| |_\/_| |_ | || | _| |_\ |_ | || | \ `--' / | || | _| |_ | || | \ `-' \_ | || | _| | \ \_ | || | |`\____) | | || | _| |_ | || | \ `--' / | || | \ ' / | || | | /\ | | || | _/ /'`\ \_ | || | _| |_ | || | _/ /__/ | | || | |_| | || | | |""",
"| ## | ##| #######/| ######/| ######/ | ########| ## | ######/| ## | ##",
"""| ||____| |____|| || | |_______/ | || | `._____.' | || | |________.' | || | |_________| | || | |_____| | || | `._____.' | || | |____||____| | || | |_____| | || | `.___.' | || | |____||____| | || | |________| | || ||_____||_____|| || ||_____|\____| | || | `.____.' | || | |_____| | || | `.___.\__| | || | |____| |___| | || | |_______.' | || | |_____| | || | `.__.' | || | \_/ | || | |__/ \__| | || | |____||____| | || | |______| | || | |________| | || | (_) | || | | |""",
"|__/ |__/|_______/ \______/ |______/ |________/|__/ \______/ |__/ |__/",
"""| | | || | | || | | || | | || | | || | | || | | || | | || | | || | | || | | || | | || | | || | | || | | || | | || | | || | | || | | || | | || | | || | | || | | || | | || | | || | | || | | || | | |""",
]
"""| '--------------' || '--------------' || '--------------' || '--------------' || '--------------' || '--------------' || '--------------' || '--------------' || '--------------' || '--------------' || '--------------' || '--------------' || '--------------' || '--------------' || '--------------' || '--------------' || '--------------' || '--------------' || '--------------' || '--------------' || '--------------' || '--------------' || '--------------' || '--------------' || '--------------' || '--------------' || '--------------' || '--------------' |""",

""" '----------------' '----------------' '----------------' '----------------' '----------------' '----------------' '----------------' '----------------' '----------------' '----------------' '----------------' '----------------' '----------------' '----------------' '----------------' '----------------' '----------------' '----------------' '----------------' '----------------' '----------------' '----------------' '----------------' '----------------' '----------------' '----------------' '----------------' '----------------' """
charSet2 = [
]
" /######## /## /## /## /## /### ### /## /## ###### /####### ",
"|__ ##__/ | ##| ## /##/| ## | ########| ### | ## /##__ ##| ##__ ##",
" | ## | ##| ## /##/ | ## | ## ## ##| ####| ##| ## | ##| ## | ##",
" | ## | ##| #####/ | ## | ## ## ##| ## ## ##| ## | ##| #######/",
" | ## | ##| ## ## | ## | ## ## ##| ## ####| ## | ##| ##____/ ",
" | ## /## | ##| ##\ ## | ## | ##__/ ##| ##\ ###| ## | ##| ## ",
" /########\ ######/| ## \ ##| ########| ## | ##| ## \ ##| ######/| ## ",
"|________/ \______/ |__/ \__/|________/|__/ |__/|__/ \__/ \______/ |__/ ",
]

charSet3 = [
" ###### /####### ###### /######## /## /## /## /## /## /## /## /##",
" /##__ ##| ##__ ## /##__ ##|__ ##__/| ## | ##| ## | ##| ## | ##\ ## /##/",
"| ## | ##| ## | ##| ## \__/ | ## | ## | ##| ## | ##| ## ## ## \ ####/ ",
"| ## | ##| #######/ \ ###### | ## | ## | ##| ## | ##| ## ## ## \ ##/ ",
"| ## ## ##| ## ## \___ ## | ## | ## | ##| ## ##/| ## ## ## / #### ",
"| ##\ ###/| ##\ ## /## \ ## | ## | ## | ## \ ####/ | ######## / ## ## ",
"| #### ##| ## \ ##\ ######/ | ## | ######/ \ ##/ | ###| ###/ ## \ ##",
" \____\__/|__/ \__/ \______/ |__/ \______/ \__/ |___/|___/\__/ \__/",
]

charSet4 = [
" /## /## /######## ###### ",
"\ ## /##/|____ ##/ /##__ ## ",
" \ ####/ / ##/ | ## | ## ",
" \ ##/ / ##/ |__//####/ ",
" | ## / ##/ | ##_/ ",
" | ## / ##/ |__/ ",
" | ## / ######## /## ",
" |__/ \________/ |__/ ",
]

# ...then the sets are combined back by barbequing them together!
charTable = [(charSet1[i] +
charSet2[i] +
charSet3[i] +
charSet4[i]) for i in range(charHeight)]


if __name__ == '__main__':
if __name__ == '__main__':
t = raw_input("Enter the text to convert :\n")
text = input("Enter the text to convert:\n")
if not t :
if not text:
t = "PYTHON"
text = "PYTHON"

for i in range(h):
for i in range(charHeight):
txt = ""
lineOut = ""
for char in t:
for chr in text:
# get dec value of T
# get value of character 'chr' in alphabet
if char.isalpha():
if chr.isalpha():
val = ord(char.upper()) - 65
val = ord(chr.upper()) - 65
elif char == " ":
elif chr == " ":
val= 27
val= 27
else:
else:
val = 26
val = 26
begin = val*l
beginStr = val * charWidth # begin string position of 3D letter
end = val*l + l
endStr = (val + 1) * charWidth # end string position of 3D letter
txt += table[i][begin:end]
lineOut += charTable[i][beginStr:endStr]
print txt
print(lineOut)</syntaxhighlight>
</lang>


{{out}}
{{out}}
<pre> /####### /## /## /######## /## /## ###### /## /##
<pre>
| ##__ ##\ ## /##/|__ ##__/| ## | ## /##__ ##| ### | ##
.----------------. .----------------. .----------------. .----------------. .----------------. .-----------------.
| ## | ## \ ####/ | ## | ## | ##| ## | ##| ####| ##
| .--------------. || .--------------. || .--------------. || .--------------. || .--------------. || .--------------. |
| #######/ \ ##/ | ## | ########| ## | ##| ## ## ##
| | ______ | || | ____ ____ | || | _________ | || | ____ ____ | || | ____ | || | ____ _____ | |
| | |_ __ \ | || | |_ _||_ _| | || | | _ _ | | || | |_ || _| | || | .' `. | || ||_ \|_ _| | |
| ##____/ | ## | ## | ##__ ##| ## | ##| ## ####
| | | |__) | | || | \ \ / / | || | |_/ | | \_| | || | | |__| | | || | / .--. \ | || | | \ | | | |
| ## | ## | ## | ## | ##| ## | ##| ##\ ###
| | | ___/ | || | \ \/ / | || | | | | || | | __ | | || | | | | | | || | | |\ \| | | |
| ## | ## | ## | ## | ##| ######/| ## \ ##
| | _| |_ | || | _| |_ | || | _| |_ | || | _| | | |_ | || | \ `--' / | || | _| |_\ |_ | |
|__/ |__/ |__/ |__/ |__/ \______/ |__/ \__/</pre>

| | |_____| | || | |______| | || | |_____| | || | |____||____| | || | `.____.' | || ||_____|\____| | |
<b>Implementation 3:</b> a more general solution that scrapes http://www.network-science.de/ascii for the ASCII art.
| | | || | | || | | || | | || | | || | | |
<syntaxhighlight lang="python">import requests
| '--------------' || '--------------' || '--------------' || '--------------' || '--------------' || '--------------' |
import html
'----------------' '----------------' '----------------' '----------------' '----------------' '----------------'

text = "Python"
font = "larry3d"
url = f"http://www.network-science.de/ascii/ascii.php?TEXT={text}&FONT={font}&RICH=no&FORM=left&WIDT=1000"

r = requests.get(url)
r.raise_for_status()

ascii_text = html.unescape(r.text)
pre_ascii = "<TD><PRE>"
post_ascii = "\n</PRE>"
ascii_text = ascii_text[ascii_text.index(pre_ascii) + len(pre_ascii):]
ascii_text = ascii_text[:ascii_text.index(post_ascii)]

print(ascii_text)</syntaxhighlight>
{{out}}
<pre> ____ __ __
/\ _`\ /\ \__ /\ \
\ \ \L\ \ __ __\ \ ,_\\ \ \___ ___ ___
\ \ ,__//\ \/\ \\ \ \/ \ \ _ `\ / __`\ /' _ `\
\ \ \/ \ \ \_\ \\ \ \_ \ \ \ \ \ /\ \L\ \/\ \/\ \
\ \_\ \/`____ \\ \__\ \ \_\ \_\\ \____/\ \_\ \_\
\/_/ `/___/> \\/__/ \/_/\/_/ \/___/ \/_/\/_/
/\___/
\/__/</pre>

=={{header|Quackery}}==

<syntaxhighlight lang="quackery">say " ________ ___ ___ ________ ________ ___ __ _______ ________ ___ ___" cr
say "|\ __ \|\ \|\ \|\ __ \|\ ____\|\ \|\ \ |\ ___ \ |\ __ \|\ \ / /|" cr
say "\ \ \|\ \ \ \ \ \ \ \|\ \ \ \___|\ \ \/ /|\ \ __/|\ \ \|\ \ \ \/ / /" cr
say " \ \ \ \ \ \ \ \ \ \ __ \ \ \ \ \ ___ \ \ \_|/ \ \ _ _\ \ / /" cr
say " \ \ \_\ \ \ \_\ \ \ \ \ \ \ \____\ \ \\ \ \ \ \__\_\ \ \\ \ / / /" cr
say " \ \_____ \ \_______\ \__\ \__\ \_______\ \__\\ \__\ \_______\ \__\\ _\ / /" cr
say " \|___| \ \|_______|\|__|\|__|\|_______|\|__| \|__|\|_______|\|__|\|__| / /" cr
say " \ \ \_______________________________________________________/ / /" cr
say " \ \____________________________________________________________/ /" cr
say " \|____________________________________________________________|/" cr</syntaxhighlight>

{{out}}

<pre> ________ ___ ___ ________ ________ ___ __ _______ ________ ___ ___
|\ __ \|\ \|\ \|\ __ \|\ ____\|\ \|\ \ |\ ___ \ |\ __ \|\ \ / /|
\ \ \|\ \ \ \ \ \ \ \|\ \ \ \___|\ \ \/ /|\ \ __/|\ \ \|\ \ \ \/ / /
\ \ \ \ \ \ \ \ \ \ __ \ \ \ \ \ ___ \ \ \_|/ \ \ _ _\ \ / /
\ \ \_\ \ \ \_\ \ \ \ \ \ \ \____\ \ \\ \ \ \ \__\_\ \ \\ \ / / /
\ \_____ \ \_______\ \__\ \__\ \_______\ \__\\ \__\ \_______\ \__\\ _\ / /
\|___| \ \|_______|\|__|\|__|\|_______|\|__| \|__|\|_______|\|__|\|__| / /
\ \ \_______________________________________________________/ / /
\ \____________________________________________________________/ /
\|____________________________________________________________|/
</pre>
</pre>



=={{header|Racket}}==
=={{header|Racket}}==
Line 2,123: Line 3,156:
Use the GUI to create a text banner:
Use the GUI to create a text banner:


<lang racket>
<syntaxhighlight lang="racket">
#lang racket/gui
#lang racket/gui


Line 2,166: Line 3,199:
(for ([line (dropf-right (dropf lines empty?) empty?)])
(for ([line (dropf-right (dropf lines empty?) empty?)])
(displayln (string-trim line #:left? #f))))
(displayln (string-trim line #:left? #f))))
</syntaxhighlight>
</lang>


{{out}}
{{out}}
Line 2,183: Line 3,216:
... ... ........ ...... ... ... ...... .....
... ... ........ ...... ... ... ...... .....
</pre>
</pre>

=={{header|Raku}}==
(formerly Perl 6)
Produces a good old-fashioned stereogram, meant to be looked at by focusing beyond the screen, not by crossing your eyes. If you can't get it to converge, try shrinking the font size till the images are closer together than your eyes. Also helps to be old enough to have progressive lenses, so you can look through the reading part of your glasses. Or borrow glasses from someone who's farsighted. <tt>:-)</tt>
<syntaxhighlight lang="raku" line># must be evenly padded with white-space$
my $text = q:to/END/;
@@@@@ @@
@ @ @ @@@
@ @ @ @@
@ @ @@@ @ @@ @ @@
@@@@@ @ @ @@ @ @ @@@@@
@ @@@@@ @ @ @@ @@
@ @ @ @ @@ @@
@ @@@ @ @@ @@@@
END

say '' for ^5;
for $text.lines -> $_ is copy {
my @chars = |｢-+ ., ;: '"｣.comb.pick(*) xx *;
s:g [' '] = @chars.shift;
print " $_ ";
s:g [('@'+)(.)] = @chars.shift ~ $0;
.say;
}
say '' for ^5;</syntaxhighlight>
{{out}}
<small><pre>




";,' :-+ . ,. ; -:+"',';-. : " + ";,' :-+ . ,. ; -:+"',';-. : " +
:@@@@@ ,'+".-; ;-+,@@"' :. ;. " :'@@@@@ ,'+".-; ;-+,,@@' :. ;. "
"@-. @ ';,+:- +: ,;@'". +@@@, "- " @. .@';,+:- +: ,;:@". +;@@@ "-
'@,- ;@ "+: .+ -',:" @; . @@; -" , ':@- ;'@"+: .+ -',:" .@ . +@@ -" ,
;@ +, @"-@@@' :@.@@ @-,:.@@+ ;'": ; @+, .@-'@@@ : @;@@ @,:.+@@ ;'":
@@@@@+-@':.@, @@" @;@ +":@@@@@', ;@@@@@--@:. @ .@@ :@ @+": @@@@@,
@;-+, .@@@@@ :@"'+' @"-,:@@; @@. +@-+, .,@@@@@::@'+' @-,: @@ "@@
:@ . "- @,;+'; @" .-'@ +:,@@ ;@@'+ :-@. "- ,@;+'; "@ .-' @+:, @@;:@@+
+@'"., ; @@@ -:@;' "@@-+.:@@@@, +:@"., ; "@@@-:;@' ".@@+.: @@@@
;.:+"-,' +:'; -," .+:" ;-.,' . ;.:+"-,' +:'; -," .+:" ;-.,' .





</pre></small>


=={{header|Raven}}==
=={{header|Raven}}==
<syntaxhighlight lang="raven">[
<lang Raven>[
" ##### #### # # #### # #"
" ##### #### # # #### # #"
" # # # # # # # ## #"
" # # # # # # # ## #"
Line 2,202: Line 3,284:
$line r/#/@@@/g r/ /X/g r/X/ /g r/@ /@!/g r/@$/@!/g as $l1
$line r/#/@@@/g r/ /X/g r/X/ /g r/@ /@!/g r/@$/@!/g as $l1
$l1 "@" split $r1 join "!" split $r2 join print "\n" print
$l1 "@" split $r1 join "!" split $r2 join print "\n" print
</syntaxhighlight>
</lang>
{{out}}
{{out}}
<pre> ///////////////> ////////////> ///> ///> ////////////> ///> ///>
<pre> ///////////////> ////////////> ///> ///> ////////////> ///> ///>
Line 2,214: Line 3,296:
=={{header|REXX}}==
=={{header|REXX}}==
===block characters===
===block characters===
The REXX program works in '''ASCII''' or [[:wp:EBCDIC|'''EBCDIC''']].
The REXX program works in &nbsp; '''ASCII''' &nbsp; or &nbsp; [[:wp:EBCDIC|'''EBCDIC''']].
<br><br>It's astonishing how much time I <del>wasted</del> spent on this program.
<br><br>It's astonishing how much time I <del>wasted</del> spent on this program.
<br>Most of the time was spent on writing comments, but the code was so easy to read, so the comments were elided. &nbsp; <font size=8> ☺ </font>
<br>Most of the time was spent on writing comments, but the code was so easy to read, so the comments were elided. &nbsp; <font size=8> ☺ </font>

<lang rexx>/*REXX program that displays a "REXX" 3D "ASCII art" as a logo. */
This REXX has been used as part of a test suite for some REXX interpreters to stress test their syntax parser.
<syntaxhighlight lang="rexx">/*REXX program that displays a "REXX" 3D "ASCII art" as a logo. */
signal . /* Uses left-hand shadows, slightly raised view.
signal . /* Uses left-hand shadows, slightly raised view.
0=5~2?A?2?A?
0=5~2?A?2?A?
Line 2,243: Line 3,327:
,13,u));_=_('=',left('',16,u));_=_('#','|\\|');_=translate(_,"|"u,'@"')
,13,u));_=_('=',left('',16,u));_=_('#','|\\|');_=translate(_,"|"u,'@"')
do k=0 for 16;x=d2x(k,1);_=_(x,left('',k+1));end;say ' '_;end;exit;_:return,
do k=0 for 16;x=d2x(k,1);_=_(x,left('',k+1));end;say ' '_;end;exit;_:return,
changestr(arg(1),_,arg(2))</lang>
changestr(arg(1),_,arg(2))</syntaxhighlight>
Some older REXXes don't have a &nbsp; '''changestr''' &nbsp; BIF, so one is included here &nbsp; ──► &nbsp; [[CHANGESTR.REX]].
Some older REXXes don't have a &nbsp; '''changestr''' &nbsp; BIF, so one is included here &nbsp; ──► &nbsp; [[CHANGESTR.REX]].

'''output'''
{{out|output|text=&nbsp; when using the internal default input:}}'''output'''
<pre>
<pre>
________________ _____________ ____ ____ ____ ____
________________ _____________ ____ ____ ____ ____
Line 2,271: Line 3,356:
{{Works with|ooRexx}}
{{Works with|ooRexx}}
{{Works with|Regina}}
{{Works with|Regina}}
<lang REXX>/* Rexx */
<syntaxhighlight lang="rexx">/* Rexx */


drop !top !bot
drop !top !bot
Line 2,337: Line 3,422:
isFalse:
isFalse:
procedure
procedure
return \isTrue()</lang>
return \isTrue()</syntaxhighlight>
{{out}}
{{out}}
<pre> ///////////////\
<pre> ///////////////\
Line 2,357: Line 3,442:
This is a version of the above REXX program (with a minor bug fixed),
This is a version of the above REXX program (with a minor bug fixed),
<br>the input text has additional spacing between the &nbsp; ''letters'' &nbsp; for better readability,
<br>the input text has additional spacing between the &nbsp; ''letters'' &nbsp; for better readability,
<br>the letter &nbsp; '''E''' &nbsp; (in the input text) was widened,
<br>the letter &nbsp; '''E''' &nbsp; (in the input text) was shortened,
<br>the output doesn't have extraneous leading blanks,
<br>the output doesn't have extraneous leading blanks,
<br>the output doesn't have trailing blanks,
<br>the output doesn't have trailing blanks,
<br>the input text can be any consistent non-blank character except the forward slash &nbsp; (<big>'''/'''</big>) &nbsp; or backward slash &nbsp;(<big>'''\'''</big>).
<br>the input text can be any consistent non-blank character except the forward slash &nbsp; (<big>'''/'''</big>) &nbsp; or backward slash &nbsp;(<big>'''\'''</big>).
<lang rexx>/*REXX pgm draws a "3D" image of text representation; any character except / and \ */
<syntaxhighlight lang="rexx">/*REXX pgm draws a "3D" image of text representation; any character except / and \ */
#=7; @.1 = '@@@@ '
#=7; @.1 = '@@@@ '
@.2 = '@ @ '
@.2 = '@ @ '
Line 2,376: Line 3,461:
$.2 = changestr( "\ ", $.2, '\/' )
$.2 = changestr( "\ ", $.2, '\/' )
do k=1 for 2; say strip(left('',#-j)$.k,"T") /*the LEFT BIF does indentation.*/
do k=1 for 2; say strip(left('',#-j)$.k,"T") /*the LEFT BIF does indentation.*/
end /*k*/ /* [↓] display a line and its shadow.*/
end /*k*/ /* [↑] display a line and its shadow.*/
end /*j*/ /*stick a fork in it, we're all done. */</lang>
end /*j*/ /*stick a fork in it, we're all done. */</syntaxhighlight>
'''output''' &nbsp; when using the default input:
{{out|output|text=&nbsp; when using the internal default input:}}
<pre>
<pre>
////////////\
////////////\
Line 2,397: Line 3,482:


=={{header|Ruby}}==
=={{header|Ruby}}==
<lang Ruby>text = <<EOS
<syntaxhighlight lang="ruby">text = <<EOS
#### #
#### #
# # #
# # #
Line 2,461: Line 3,546:
#
#
#
#
EOS</lang>
EOS</syntaxhighlight>


{{out}}
{{out}}
Line 2,509: Line 3,594:


'''Another version:''' like a 3D solid.
'''Another version:''' like a 3D solid.
<lang Ruby>enc = "9 8u18 2u1\n8 1s 6u1 b16 1s sb\n6 2 s1b4u1s sb13 3 s1\n5 3 s3 3s 11 3 s1\n4 2 s1us3u1su2s 2u4 2u3 2 s1us3u4 2u6 2u1\n4 1s 6u1sbubs2 s1b 2 s1b2 1s 6u1 b2 1susb3 2 s1b\n2 2 s1b2 3u1bs2 8 s1b4u1s s4b 3 s1\n 3 s3b 2 9 s3 3s 3 b2s 1s\n 3s 3 b1 2 s2us4 s1us2u2us1 s3 3 b1s s\nsu2s 2 4 b6u2s 1s7u1sbubs6 1bub2 1s\nbubs6 1bubs2 1b5u1bs b7u1bs8 3 s1\n42 2u2s 1s\n41 1s3u1s s\n41 1b3u1bs\n"
<syntaxhighlight lang="ruby">enc = "9 8u18 2u1\n8 1s 6u1 b16 1s sb\n6 2 s1b4u1s sb13 3 s1\n5 3 s3 3s 11 3 s1\n4 2 s1us3u1su2s 2u4 2u3 2 s1us3u4 2u6 2u1\n4 1s 6u1sbubs2 s1b 2 s1b2 1s 6u1 b2 1susb3 2 s1b\n2 2 s1b2 3u1bs2 8 s1b4u1s s4b 3 s1\n 3 s3b 2 9 s3 3s 3 b2s 1s\n 3s 3 b1 2 s2us4 s1us2u2us1 s3 3 b1s s\nsu2s 2 4 b6u2s 1s7u1sbubs6 1bub2 1s\nbubs6 1bubs2 1b5u1bs b7u1bs8 3 s1\n42 2u2s 1s\n41 1s3u1s s\n41 1b3u1bs\n"
def decode(str)
def decode(str)
str.split(/(\d+)(\D+)/).each_slice(3).map{|_,n,s| s * n.to_i}.join.tr('sub','/_\\')
str.split(/(\d+)(\D+)/).each_slice(3).map{|_,n,s| s * n.to_i}.join.tr('sub','/_\\')
end
end
puts decode(enc)</lang>
puts decode(enc)</syntaxhighlight>


{{out}}
{{out}}
Line 2,532: Line 3,617:
\___\/
\___\/
</pre>
</pre>

=={{header|Rust}}==
<syntaxhighlight lang="rust">pub fn char_from_id(id: u8) -> char {
[' ', '#', '/', '_', 'L', '|', '\n'][id as usize]
}

const ID_BITS: u8 = 3;

pub fn decode(code: &[u8]) -> String {
let mut ret = String::new();
let mut carry = 0;
let mut carry_bits = 0;
for &b in code {
let mut bit_pos = ID_BITS - carry_bits;
let mut cur = b >> bit_pos;
let mask = (1 << bit_pos) - 1;
let id = carry | (b & mask) << carry_bits;
ret.push(char_from_id(id));
while bit_pos + ID_BITS < 8 {
ret.push(char_from_id(cur & ((1 << ID_BITS) - 1)));
cur >>= ID_BITS;
bit_pos += ID_BITS;
}
carry = cur;
carry_bits = 8 - bit_pos;
}
ret
}

fn main() {
let code = [
72, 146, 36, 0, 0, 0, 0, 0, 0, 0, 128, 196, 74, 182, 41, 1, 0, 0, 0, 0, 0, 0, 160, 196, 77, 0,
52, 1, 18, 0, 9, 144, 36, 9, 146, 36, 113, 147, 36, 9, 160, 4, 80, 130, 100, 155, 160, 41, 145,
155, 108, 74, 128, 38, 64, 19, 41, 73, 2, 160, 137, 155, 0, 84, 130, 38, 64, 19, 112, 155, 18,
160, 137, 155, 0, 160, 18, 42, 73, 18, 36, 73, 2, 128, 74, 76, 1, 0, 40, 128, 219, 38, 104, 219,
4, 0, 160, 0
];

println!("{}", decode(&code));
}</syntaxhighlight>

{{out}}
<pre> ####### ##
/##___/## /##
|## |## ## ## ###### ######
|####### /## /## ##___/ /_/##/
|##__/## |## |##//##### |##
|## L/## |## |## L___/## |##
|## L/##L/###### ###### L/##
L/ L/ L____/ /____/ L/ </pre>


=={{header|Scala}}==
=={{header|Scala}}==
{{libheader|Scala}}
{{libheader|Scala}}
===Java style===
===Java style===
<lang Scala>def ASCII3D = {
<syntaxhighlight lang="scala">def ASCII3D = {


val name = """
val name = """
Line 2,597: Line 3,732:
}
}


println(ASCII3D)</lang>
println(ASCII3D)</syntaxhighlight>
===Idiomatic===
===Idiomatic===
Cleaner code.
Cleaner code.
<lang scala>import scala.collection.mutable.ArraySeq
<syntaxhighlight lang="scala">import scala.collection.mutable.ArraySeq


object Ascii3D extends App {
object Ascii3D extends App {
Line 2,640: Line 3,775:


println(ASCII3D)
println(ASCII3D)
}</lang>
}</syntaxhighlight>
{{out}}
{{out}}
<pre>
<pre>
Line 2,656: Line 3,791:


=={{header|Seed7}}==
=={{header|Seed7}}==
<lang seed7>$include "seed7_05.s7i";
<syntaxhighlight lang="seed7">$include "seed7_05.s7i";


const array string: name is [] (
const array string: name is [] (
Line 2,697: Line 3,832:
end for;
end for;
writeln(previousLine);
writeln(previousLine);
end func;</lang>
end func;</syntaxhighlight>


{{out}}
{{out}}
Line 2,715: Line 3,850:
=={{header|Sidef}}==
=={{header|Sidef}}==
{{trans|Ruby}}
{{trans|Ruby}}
<lang ruby>var text = <<'EOT';
<syntaxhighlight lang="ruby">var text = <<'EOT';


***
***
Line 2,735: Line 3,870:
};
};


say banner3D(text);</lang>
say banner3D(text);</syntaxhighlight>
<pre>
<pre>
Line 2,751: Line 3,886:


=={{header|SQL}}==
=={{header|SQL}}==
<lang sql>select ' SSS\ ' as s, ' QQQ\ ' as q, 'L\ ' as l from dual
<syntaxhighlight lang="sql">select ' SSS\ ' as s, ' QQQ\ ' as q, 'L\ ' as l from dual
union all select 'S \|', 'Q Q\ ', 'L | ' from dual
union all select 'S \|', 'Q Q\ ', 'L | ' from dual
union all select '\SSS ', 'Q Q |', 'L | ' from dual
union all select '\SSS ', 'Q Q |', 'L | ' from dual
Line 2,757: Line 3,892:
union all select ' SSS |', '\QQQ\\|', 'LLLL\' from dual
union all select ' SSS |', '\QQQ\\|', 'LLLL\' from dual
union all select ' \__\/', ' \_Q_/ ', '\___\' from dual
union all select ' \__\/', ' \_Q_/ ', '\___\' from dual
union all select ' ', ' \\ ', ' ' from dual;</lang>
union all select ' ', ' \\ ', ' ' from dual;</syntaxhighlight>
This works in Oracle. For other databases, try it without "from dual".
This works in Oracle. For other databases, try it without "from dual".
{{out}}
{{out}}
Line 2,774: Line 3,909:


=={{header|Tcl}}==
=={{header|Tcl}}==
<lang tcl>package require Tcl 8.5
<syntaxhighlight lang="tcl">package require Tcl 8.5


proc mergeLine {upper lower} {
proc mergeLine {upper lower} {
Line 2,809: Line 3,944:
{ * *** *}
{ * *** *}
}
}
printLines $lines</lang>
printLines $lines</syntaxhighlight>
{{out}}
{{out}}
<pre>
<pre>
Line 2,819: Line 3,954:
///\/ /////////\ ///\/
///\/ /////////\ ///\/
\\\/ \\\\\\\\\/ \\\/
\\\/ \\\\\\\\\/ \\\/
</pre>

=={{header|UNIX Shell}}==
{{works with|Bash|4}}
<syntaxhighlight lang="sh">#!/usr/bin/env bash
mapfile -t name <<EOF
Aimhacks
EOF

main() {
banner3d_1 "${name[@]}"
echo
banner3d_2 "${name[@]}"
echo
banner3d_3 "${name[@]}"
}

space() {
local -i n i
(( n=$1 )) || n=1
if (( n < 1 )); then n=1; fi
for ((i=0; i<n; ++i)); do
printf ' '
done
printf '\n'
}

banner3d_1() {
local txt i
mapfile -t txt < <(printf '%s\n' "$@" | sed -e 's,#,__/,g' -e 's/ / /g')
for i in "${!txt[@]}"; do
printf '%s%s\n' "$(space $(( ${#txt[@]} - i )))" "${txt[i]}"
done
}

banner3d_2() {
local txt i line line2
mapfile -t txt < <(printf '%s \n' "$@")
for i in "${!txt[@]}"; do
line=${txt[i]}
line2=$(printf '%s%s' "$(space $(( 2 * (${#txt[@]} - i) )))" "$(sed -e 's, , ,g' -e 's,#,///,g' -e 's,/ ,/\\,g' <<<"$line")")
printf '%s\n%s\n' "$line2" "$(tr '/\\' '\\/' <<<"$line2")"
done
}

banner3d_3() {
# hard-coded fancy one
cat <<'EOF'
______________ ___________ ___________ ____ ____␣
/ /\ / |\ /| \ |\ \ |\ \
/_____________/ /| /___________|| ||___________\| \___\ | \___\␣
| \ / |/ \ / | | | | | |
| ________ | | ________ | | _________| | | | | |
| | |___| | | | |____| | | |_______ | | |____| | |
| | / | | /| | / | | | | \ | | | \ | |
| |/_____| |/ | |/_____| | | |________\| | |______\| |
| / /| | | \ | |
| ______ \ / | _______ | \_________ | | ________ |
| | |___| | | | | | | _________/| | | | | | |
| | / | | | | | | | | || | | | | | |
| |/_____| | /| | | | | |_________|/ | | | \ | |
| |/ | | | | | | | | | \| |
|_____________/ |___|/ |___| |_____________/ \|___| |___|
EOF
}

main "$@"
</syntaxhighlight>
{{Out}}
<pre> __/__/__/ __/
__/ __/ __/
__/ __/ __/
__/__/__/ __/__/ __/__/__/ __/__/__/
__/ __/ __/ __/ __/ __/
__/ __/ __/__/__/__/ __/__/ __/ __/
__/ __/ __/ __/__/ __/ __/ __/
__/__/__/ __/__/ __/ __/__/__/ __/ __/

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

______________ ___________ ___________ ____ ____␣
/ /\ / |\ /| \ |\ \ |\ \
/_____________/ /| /___________|| ||___________\| \___\ | \___\␣
| \ / |/ \ / | | | | | |
| ________ | | ________ | | _________| | | | | |
| | |___| | | | |____| | | |_______ | | |____| | |
| | / | | /| | / | | | | \ | | | \ | |
| |/_____| |/ | |/_____| | | |________\| | |______\| |
| / /| | | \ | |
| ______ \ / | _______ | \_________ | | ________ |
| | |___| | | | | | | _________/| | | | | | |
| | / | | | | | | | | || | | | | | |
| |/_____| | /| | | | | |_________|/ | | | \ | |
| |/ | | | | | | | | | \| |
|_____________/ |___|/ |___| |_____________/ \|___| |___|
</pre>

=={{header|Visual Basic .NET}}==
{{trans|C#}}
<syntaxhighlight lang="vbnet">Module Module1

Sub Main()
Console.WriteLine(" ___ ___ ___ ________ ___ ___ ________ ___ ________ ________ ________ ___ ________ ________ _______ _________
|\ \ / /|\ \|\ ____\|\ \|\ \|\ __ \|\ \ |\ __ \|\ __ \|\ ____\|\ \|\ ____\ |\ ___ \|\ ___ \|\___ ___\
\ \ \ / / | \ \ \ \___|\ \ \\\ \ \ \|\ \ \ \ \ \ \|\ /\ \ \|\ \ \ \___|\ \ \ \ \___| \ \ \\ \ \ \ __/\|___ \ \_|
\ \ \/ / / \ \ \ \_____ \ \ \\\ \ \ __ \ \ \ \ \ __ \ \ __ \ \_____ \ \ \ \ \ \ \ \\ \ \ \ \_|/__ \ \ \
\ \ / / \ \ \|____|\ \ \ \\\ \ \ \ \ \ \ \____ \ \ \|\ \ \ \ \ \|____|\ \ \ \ \ \____ __\ \ \\ \ \ \ \_|\ \ \ \ \
\ \__/ / \ \__\____\_\ \ \_______\ \__\ \__\ \_______\ \ \_______\ \__\ \__\____\_\ \ \__\ \_______\ |\__\ \__\\ \__\ \_______\ \ \__\
\|__|/ \|__|\_________\|_______|\|__|\|__|\|_______| \|_______|\|__|\|__|\_________\|__|\|_______| \|__|\|__| \|__|\|_______| \|__|
\|_________| \|_________|
")
End Sub

End Module</syntaxhighlight>
{{out}}
<pre> ___ ___ ___ ________ ___ ___ ________ ___ ________ ________ ________ ___ ________ ________ _______ _________
|\ \ / /|\ \|\ ____\|\ \|\ \|\ __ \|\ \ |\ __ \|\ __ \|\ ____\|\ \|\ ____\ |\ ___ \|\ ___ \|\___ ___\
\ \ \ / / | \ \ \ \___|\ \ \\\ \ \ \|\ \ \ \ \ \ \|\ /\ \ \|\ \ \ \___|\ \ \ \ \___| \ \ \\ \ \ \ __/\|___ \ \_|
\ \ \/ / / \ \ \ \_____ \ \ \\\ \ \ __ \ \ \ \ \ __ \ \ __ \ \_____ \ \ \ \ \ \ \ \\ \ \ \ \_|/__ \ \ \
\ \ / / \ \ \|____|\ \ \ \\\ \ \ \ \ \ \ \____ \ \ \|\ \ \ \ \ \|____|\ \ \ \ \ \____ __\ \ \\ \ \ \ \_|\ \ \ \ \
\ \__/ / \ \__\____\_\ \ \_______\ \__\ \__\ \_______\ \ \_______\ \__\ \__\____\_\ \ \__\ \_______\ |\__\ \__\\ \__\ \_______\ \ \__\
\|__|/ \|__|\_________\|_______|\|__|\|__|\|_______| \|_______|\|__|\|__|\_________\|__|\|_______| \|__|\|__| \|__|\|_______| \|__|
\|_________| \|_________|
</pre>

=={{header|Wren}}==
This uses the 3D ASCII letter font [https://github.com/arpan98/3dwrite/blob/master/3d_font.txt here].
<syntaxhighlight lang="wren">var w = """
____ ____ ____
|\ \ |\ \ |\ \
| \ \ | \ \ | \ \
\ \ \\ / \\ / /|
\ \ \V \V / |
\ \ /\ / /
\ \____/ \____/ /
\ | | /| | /
\|____|/ |____|/
""".split("\n")

var r = """
_______ ____
|\__ \ / \
|| |\ \/ ___\
\|_| \ /|__|
\ \ //
\ \ \
\ \____\
\ | |
\|____|
""".split("\n")

var e = """
___________
/ _____ \
/ /_____\ \
|\ _____/|
| \ /|____|/
\ \ \/_______/\
\ \_____________/|
\ | | |
\|____________|/
""".split("\n")

var n = """
_____ _______
|\__ \/ \
|| |\ __ \
\|_| \ /| \ \
\ \ \/\ \ \
\ \ \ \ \ \
\ \___\ \ \___\
\ | | \| |
\|___| |___|
""".split("\n")

for (i in 0..8) {
System.print("%(w[i]) %(r[i]) %(e[i]) %(n[i])")
}</syntaxhighlight>

{{out}}
<pre>
____ ____ ____ _______ ____ ___________ _____ _______
|\ \ |\ \ |\ \ |\__ \ / \ / _____ \ |\__ \/ \
| \ \ | \ \ | \ \ || |\ \/ ___\ / /_____\ \ || |\ __ \
\ \ \\ / \\ / /| \|_| \ /|__| |\ _____/| \|_| \ /| \ \
\ \ \V \V / | \ \ // | \ /|____|/ \ \ \/\ \ \
\ \ /\ / / \ \ \ \ \ \/_______/\ \ \ \ \ \ \
\ \____/ \____/ / \ \____\ \ \_____________/| \ \___\ \ \___\
\ | | /| | / \ | | \ | | | \ | | \| |
\|____|/ |____|/ \|____| \|____________|/ \|___| |___|
</pre>
</pre>


=={{header|XPL0}}==
=={{header|XPL0}}==
Here's XPL0's "cheap hack." (Hats off to D!)
Here's XPL0's "cheap hack." (Hats off to D!)
<lang XPL0>include c:\cxpl\codes;
<syntaxhighlight lang="xpl0">include c:\cxpl\codes;


proc DrawBlock(X, Y);
proc DrawBlock(X, Y);
Line 2,849: Line 4,192:
];
];
];
];
]</lang>
]</syntaxhighlight>


{{out}}
{{out}}
Line 2,870: Line 4,213:
\\\/ \\\/ \\\/ \\\\\\\\\\\/ \\\\\\\/
\\\/ \\\/ \\\/ \\\\\\\\\\\/ \\\\\\\/
</pre>
</pre>

=={{header|Yabasic}}==
<syntaxhighlight lang="yabasic">
// Method 1
// r$ = system$("explorer \"http://www.network-science.de/ascii/ascii.php?TEXT=${delegate}&x=23&y=10&FONT=block&RICH=no&FORM=left&STRE=no&WIDT=80&TEXT=Yabasic\"")

// Method 2
// print
// print " _| _| _| _| "
// print " _| _| _|_|_| _|_|_| _|_|_| _|_|_| _|_|_| "
// print " _| _| _| _| _| _| _| _|_| _| _| "
// print " _| _| _| _| _| _| _| _|_| _| _| "
// print " _| _|_|_| _|_|_| _|_|_| _|_|_| _| _|_|_| "
// print

// Method 3
clear screen

dim d$(5)

d$(0) = "X X X XXXX X XXX X XXX "
d$(1) = " X X X X X X X X X X X X"
d$(2) = " X XXXXX XXXX XXXXX XXX X X "
d$(3) = " X X X X X X X X X X X"
d$(4) = " X X X XXXX X X XXXX X XXX "

long = len(d$(0))

sub write(dx, dy, c$)
local x, y
for y = 0 to 4
for x = 0 to long
if mid$(d$(y), x, 1) = "X" print at(x + dx, y + dy) c$
next x
next y
end sub

write(2, 2, "\\")
write(1, 1, "#")
print</syntaxhighlight>


=={{header|zkl}}==
=={{header|zkl}}==
{{trans|Common Lisp}}
{{trans|Common Lisp}}
<lang zkl>#<<<
<syntaxhighlight lang="zkl">#<<<
"
"
xxxxxx x x x
xxxxxx x x x
x x x x
x x x x
x x x x
x x x x
x x x x
x x x x
xxxxx x x xxxx
xxxxx x x xxxx
"
"
#<<<<
#<<<<
.replace(" "," ").replace("x","_/").println();</lang>
.replace(" "," ").replace("x","_/").println();</syntaxhighlight>
{{out}}
{{out}}
<pre>
<pre>


_/_/_/_/_/_/ _/ _/ _/
_/_/_/_/_/_/ _/ _/ _/
_/ _/ _/ _/
_/ _/ _/ _/
_/ _/ _/ _/
_/ _/ _/ _/
_/ _/ _/ _/
_/ _/ _/ _/
_/_/_/_/_/ _/ _/ _/_/_/_/
_/_/_/_/_/ _/ _/ _/_/_/_/


</pre>
</pre>

Latest revision as of 14:51, 1 March 2024

Task
Write language name in 3D ASCII
You are encouraged to solve this task according to the task description, using any language you may know.
Task

Write/display a language's name in 3D ASCII.


(We can leave the definition of "3D ASCII" fuzzy, so long as the result is interesting or amusing, not a cheap hack to satisfy the task.)


Related tasks



11l

V s =
|‘  XX
     X
     X
     X
     X
     X
   XXXXX’

V lines = s.split("\n")
V width = max(lines.map(l -> l.len))

L(line) lines
   print((‘ ’ * (lines.len - L.index - 1))‘’(line.ljust(width).replace(‘ ’, ‘   ’).replace(‘X’, ‘__/’) * 3))
Output:
            __/__/            __/__/            __/__/      
              __/               __/               __/      
             __/               __/               __/      
            __/               __/               __/      
           __/               __/               __/      
          __/               __/               __/      
   __/__/__/__/__/   __/__/__/__/__/   __/__/__/__/__/

360 Assembly

3D EBCDIC. This program does nothing clever in any way: it just prints out strings. 

THREED   CSECT
         STM   14,12,12(13)
         BALR  12,0
         USING *,12
         XPRNT =CL23'0 ####.     #.     ###.',23
         XPRNT =CL24'1     #.  #.      #.  #.',24
         XPRNT =CL24'1   ##.   # ##.   #.  #.',24
         XPRNT =CL24'1     #.  #.  #.  #.  #.',24
         XPRNT =CL23'1 ####.    ###.    ###.',23
         LM    14,12,12(13)
         BR    14
         LTORG
         END
Output:

 ####.     #.     ###.
     #.  #.      #.  #.
   ##.   # ##.   #.  #.
     #.  #.  #.  #.  #.
 ####.    ###.    ###.

Action!

Atari 8-bit computers use ATASCII character set which is a variation of ASCII. 

BYTE ARRAY data = [
  $00 $00 $00 $00 $4E $4E $4E $00 $00 $00 $00 $00 $00 $00 $00 $00 $4E $00 $00 $00 $00 $4E $00 $00 $00 $00 $00 $00 $00 $00 $00 $00 $00 $00 $00 $00 $4E $00 $00 $00 
  $00 $00 $00 $46 $47 $00 $00 $47 $00 $00 $00 $00 $00 $00 $00 $42 $47 $47 $00 $00 $42 $47 $47 $00 $00 $00 $00 $00 $00 $00 $00 $00 $00 $00 $00 $42 $47 $47 $00 $00 
  $00 $00 $42 $47 $48 $80 $80 $80 $4A $00 $00 $4E $4E $4E $00 $42 $00 $80 $4E $00 $00 $47 $80 $00 $00 $4E $4E $00 $00 $00 $4E $4E $4E $00 $00 $42 $00 $80 $00 $00 
  $00 $00 $42 $00 $80 $00 $42 $00 $80 $00 $46 $47 $00 $00 $47 $42 $00 $80 $00 $47 $00 $4E $00 $00 $46 $47 $00 $47 $00 $42 $47 $00 $00 $47 $00 $42 $00 $80 $00 $00 
  $00 $00 $42 $00 $80 $00 $42 $00 $80 $42 $47 $48 $80 $80 $80 $42 $00 $80 $80 $80 $42 $47 $47 $42 $47 $48 $80 $80 $4A $42 $00 $80 $80 $80 $4A $42 $00 $80 $00 $00 
  $00 $00 $42 $00 $80 $4D $4D $47 $80 $42 $00 $80 $00 $00 $00 $42 $00 $80 $00 $00 $42 $00 $80 $42 $00 $80 $42 $00 $80 $42 $00 $80 $42 $00 $80 $42 $00 $80 $00 $00 
  $00 $00 $42 $00 $80 $80 $80 $80 $80 $42 $00 $80 $00 $00 $00 $42 $00 $80 $00 $00 $42 $00 $80 $42 $00 $80 $42 $00 $80 $42 $00 $80 $42 $00 $80 $00 $47 $80 $00 $00 
  $00 $00 $42 $00 $80 $00 $42 $00 $80 $42 $00 $80 $4E $4E $00 $42 $00 $80 $4E $00 $42 $00 $80 $42 $00 $80 $42 $00 $80 $42 $00 $80 $42 $00 $80 $00 $4E $00 $00 $00 
  $00 $00 $42 $00 $80 $00 $42 $00 $80 $00 $47 $80 $00 $00 $47 $00 $47 $80 $00 $47 $42 $00 $80 $00 $47 $80 $4D $47 $80 $42 $00 $80 $42 $00 $80 $42 $47 $47 $00 $00 
  $00 $00 $00 $47 $80 $00 $00 $47 $80 $00 $00 $CA $80 $80 $80 $00 $00 $CA $80 $80 $00 $47 $80 $00 $00 $CA $80 $80 $C8 $00 $47 $80 $00 $47 $80 $00 $47 $80 $00 $00]

PROC Main()
  BYTE POINTER ptr

  Graphics(0)
  SetColor(2,0,2)
  ptr=PeekC(88)+280
  MoveBlock(ptr,data,400)
RETURN
Output:

Screenshot from Atari 8-bit computer

Ada

Quotes are not escaped by \ in ada (nor does \ have any meaning in strings), so this turns out highlighting funny. 

with Ada.Text_IO; use Ada.Text_IO;
with Ada.Strings.Fixed; use Ada.Strings.Fixed;
procedure AsciiArt is
   art : constant array(1..27) of String(1..14) :=
     (1=>"    /\\\\\\   ", 2=>"          /\\\",
      3|6|9=>"              ", 4|12=>"  /\\\\\\\\\\ ",
      5|8|11=>"         \/\\\", 7|17|21=>" /\\\//////\\\",
      10|19|20|22=>"\/\\\    \/\\\", 13|23|24=>"\/\\\\\\\\\\\\",
      14|18=>"  /\\\\\\\\\\\", 15=>" \/////////\\\",
      16=>"\/\\\//////\\\", 25=>"\///     \/// ",
      26|27=>"\//////////// ");
begin
   for i in art'Range loop
      Put(art(i)&' ');
      if i mod 3 = 0 then New_Line; Put(i/3*' '); end if;
   end loop;
end AsciiArt;
Output:
    /\\\\\\              /\\\
   /\\\\\\\\\\           \/\\\
   /\\\//////\\\          \/\\\
   \/\\\    \/\\\          \/\\\   /\\\\\\\\\\
    \/\\\\\\\\\\\\   /\\\\\\\\\\\  \/////////\\\
     \/\\\//////\\\  /\\\//////\\\   /\\\\\\\\\\\
      \/\\\    \/\\\ \/\\\    \/\\\  /\\\//////\\\
       \/\\\    \/\\\ \/\\\\\\\\\\\\ \/\\\\\\\\\\\\
        \///     \///  \////////////  \////////////

Arturo

print {:
 ______         __                           
/\  _  \       /\ \__                        
\ \ \L\ \  _ __\ \ ,_\  __  __  _ __   ___   
 \ \  __ \/\`'__\ \ \/ /\ \/\ \/\`'__\/ __`\ 
  \ \ \/\ \ \ \/ \ \ \_\ \ \_\ \ \ \//\ \L\ \
   \ \_\ \_\ \_\  \ \__\\ \____/\ \_\\ \____/
    \/_/\/_/\/_/   \/__/ \/___/  \/_/ \/___/                                              
:}
Output:
 ______         __                           
/\  _  \       /\ \__                        
\ \ \L\ \  _ __\ \ ,_\  __  __  _ __   ___   
 \ \  __ \/\`'__\ \ \/ /\ \/\ \/\`'__\/ __`\ 
  \ \ \/\ \ \ \/ \ \ \_\ \ \_\ \ \ \//\ \L\ \
   \ \_\ \_\ \_\  \ \__\\ \____/\ \_\\ \____/
    \/_/\/_/\/_/   \/__/ \/___/  \/_/ \/___/

AutoHotkey

AutoTrim, Off
draw =
(
 ______  __  __  __  __    
/\  __ \/\ \_\ \/\ \/ /    
\ \  __ \ \  __ \ \  _"-.  
 \ \_\ \_\ \_\ \_\ \_\ \_\ 
  \/_/\/_/\/_/\/_/\/_/\/_/ 
)
Gui, +ToolWindow
Gui, Color, 1A1A1A, 1A1A1A
Gui, Font, s8 cLime w800, Courier New
Gui, Add, text, x4 y0 , % " " draw
Gui, Show, w192 h82, AHK in 3D
return

GuiClose:
ExitApp
Output:
 ______  __  __  __  __    
/\  __ \/\ \_\ \/\ \/ /    
\ \  __ \ \  __ \ \  _"-.  
 \ \_\ \_\ \_\ \_\ \_\ \_\ 
  \/_/\/_/\/_/\/_/\/_/\/_/

AWK

# syntax: GAWK -f WRITE_LANGUAGE_NAME_IN_3D_ASCII.AWK
BEGIN {
    arr[1] = " xxxx    x    x   x   x"
    arr[2] = "x    x   x    x   x  x"
    arr[3] = "x    x   x    x   x x"
    arr[4] = "xxxxxx   x    x   xx"
    arr[5] = "x    x   x xx x   xx"
    arr[6] = "x    x   xx  xx   x x"
    arr[7] = "x    x   xx  xx   x  x"
    arr[8] = "A    V   P    J   B   W"
    for (i=1; i<=8; i++) {
      x = arr[i]
      gsub(/./,"& ",x)
      gsub(/[xA-Z] /,"_/",x)
      print(x)
    }
    exit(0)
}
Output:
  _/_/_/_/        _/        _/      _/      _/
_/        _/      _/        _/      _/    _/
_/        _/      _/        _/      _/  _/
_/_/_/_/_/_/      _/        _/      _/_/
_/        _/      _/  _/_/  _/      _/_/
_/        _/      _/_/    _/_/      _/  _/
_/        _/      _/_/    _/_/      _/    _/
_/        _/      _/        _/      _/      _/

BASIC

Applesoft BASIC

Ported from ZX Spectrum Basic.

10 S$ = "BASIC" : REM OUR LANGUAGE NAME
20 DIM B(5,5) : REM OUR BIGMAP CHARACTERS
30 FOR L = 1 TO 5 : REM 5 CHARACTERS
40     FOR M = 1 TO 5 : REM 5 ROWS
50         READ B(L,M)
60 NEXT M, L

100 GR : REM BLACK BACKGROUND
110 COLOR = 1 : REM OUR SHADOW WILL BE RED
120 HOME : REM CLS
130 R = 9 : REM SHADOW WILL START ON ROW 5
140 C = 2 : REM SHADOW WILL START AT COLUMN 2
150 GOSUB 2000"DRAW SHADOW
160 COLOR = 13 : REM OUR FOREGROUND WILL BE YELLOW
170 R = 10 : REM FOREGROUND WILL START ON ROW 6
180 C = 3 : REM FOREGROUND WILL START ON COLUMN 3
190 GOSUB 2000"DISPLAY THE LANGUAGE NAME

999 STOP

1000 REM CONVERT TO BINARY BIGMAP
1010 T = N : REM TEMPORARY VARIABLE
1020 G$ = "" : REM THIS WILL CONTAIN OUR 5 CHARACTER BINARY BIGMAP
1040 FOR Z = 5 TO 0 STEP -1
1050     D$ = " " : REM ASSUME NEXT DIGIT IS ZERO (DRAW A SPACE)
1055     S = 2 ^ Z
1060     IF T >= S THEN D$ = "*" : T = T - S : REM IS A BLOCK
1070     G$ = G$ + D$
1080 NEXT Z
1090 RETURN

2000 REM DISPLAY THE BIG LETTERS
2010 FOR L = 1 TO 5 : REM OUR 5 ROWS
2020     X = C : Y = R + L - 1 : REM PRINT AT R+L-1,C;
2030     FOR M = 1 TO 5 : REM BIGMAP FOR EACH CHARACTER
2040         N = B(M, L)
2050         GOSUB 1000
2060         FOR I = 1 TO LEN(G$) : IF MID$(G$, I, 1) <> " " THEN PLOT X,Y :REM 5 CHARACTER BIGMAP
2070             X = X + 1 : NEXT I
2080         X = X + 1 : REM PRINT " ";: REM SPACE BETWEEN EACH LETTER
2090 NEXT M, L
2100 RETURN

9000 DATA 30,17,30,17,30: REM B
9010 DATA 14,17,31,17,17: REM A
9020 DATA 15,16,14,1,30: REM S
9030 DATA 31,4,4,4,31: REM I
9040 DATA 14,17,16,17,14: REM C

BBC BASIC

Works with: BBC BASIC for Windows

Uses the built-in BBC Micro-compatible character generator, so any text can be specified. 

      PROC3dname("BBC BASIC")
      END
      
      DEF PROC3dname(name$)
      LOCAL A%, X%, Y%, char%, row%, patt%, bit%
      DIM X% 8 : A% = 10 : Y% = X% DIV 256
      FOR row% = 1 TO 8
        FOR char% = 1 TO LEN(name$)
          ?X% = ASCMID$(name$,char%)
          CALL &FFF1
          patt% = X%?row%
          FOR bit% = 7 TO 0 STEP -1
            CASE TRUE OF
              WHEN (patt% AND 2^bit%) <> 0 : PRINT "#";
              WHEN GET$(POS-1,VPOS-1) = "#": PRINT "\";
              OTHERWISE: PRINT " ";
            ENDCASE
          NEXT
        NEXT char%
        PRINT
      NEXT row%
      ENDPROC
Output:
#####   #####    ####           #####    ####    ####   ######   ####
##\\##  ##\\##  ##\\##          ##\\##  ##\\##  ##\\##   \##\\\ ##\\##
##\ ##\ ##\ ##\ ##\  \\         ##\ ##\ ##\ ##\ ##\  \\   ##\   ##\  \\
#####\\ #####\\ ##\             #####\\ ######\  ####     ##\   ##\
##\\##  ##\\##  ##\             ##\\##  ##\\##\   \\##    ##\   ##\
##\ ##\ ##\ ##\ ##\ ##          ##\ ##\ ##\ ##\ ##  ##\   ##\   ##\ ##
#####\\ #####\\  ####\\         #####\\ ##\ ##\  ####\\ ######   ####\\
 \\\\\   \\\\\    \\\\           \\\\\   \\  \\   \\\\   \\\\\\   \\\\

FreeBASIC

freebasic is quite a long name, so I have done a combi. 

dim as integer yres=hiword(width)
dim as integer xres=loword(width)

#define map(a,b,x,c,d)  ((d)-(c))*((x)-(a))/((b)-(a))+(c)
#define _X(num) int( map(0,xres,(num),0,loword(width))) 
#define _Y(num) int( map(0,yres,(num),0,hiword(width)))

Type pt
    As Integer x,y
End Type
Dim As pt a(1 To ...)=_
{(4,2),(6,2),(8,2),(12,2),(14,2),(16,2),(20,2),(22,2),(24,2),(28,2),(30,2),(32,2),_
(4,3),(12,3),(16,3),(20,3),(28,3),_
(4,4),(6,4),(12,4),(14,4),(16,4),(20,4),(22,4),(28,4),(30,4),_
(4,5),(12,5),(20,5),(28,5),_
(4,6),(12,6),(16,6),(20,6),(22,6),(24,6),(28,6),(30,6),(32,6)}


For i As Integer=0 To 12
    For n As Integer=Lbound(a) To Ubound(a)
        Locate _Y(a(n).y+i),_X(a(n).x+i)
        If i<12 Then Print "\" Else Print "#"
    Next n
Next i
locate(csrlin-1,40)
print "BASIC"
Sleep
Output:
   \ \ \   \ \ \   \ \ \   \ \ \
   \\ \ \  \\ \\\  \\ \ \  \\ \ \
   \\\ \ \ \\\ \\\ \\\ \ \ \\\ \ \
   \\\\ \ \\\\\ \\\\\\\ \ \\\\\ \ \
   \\\\\ \ \\\\\ \\\\\\\ \ \\\\\ \ \
    \\\\\ \ \\\\\ \\\\\\\ \ \\\\\ \ \
     \\\\\ \ \\\\\ \\\\\\\ \ \\\\\ \ \
      \\\\\ \ \\\\\ \\\\\\\ \ \\\\\ \ \
       \\\\\ \ \\\\\ \\\\\\\ \ \\\\\ \ \
        \\\\\ \ \\\\\ \\\\\\\ \ \\\\\ \ \
         \\\\\ \ \\\\\ \\\\\\\ \ \\\\\ \ \
          \\\\\ \ \\\\\ \\\\\\\ \ \\\\\ \ \
           \\\\# # #\\\# #\#\\\# # #\\\# # #
            \\\#\   \\\#\ \#\\\#\   \\\#\
             \\# #   \\# # # \\# #   \\# #
              \#      \#  \   \#\ \   \#\ \
               #       #   #   # # #   BASIC

Liberty BASIC

r=21:s=9:c=s
For i=1 To 11
    Read d
    If d <> 0 Then
        For j=1 To 31
            If (d And(2^(31-j)))>0 Then
                Locate c+1,r:Print  "___";
                Locate c,r+1:Print "/_ /|";
                Locate c,r+2:Print "[_]/";
            End If
        c=c+3
        Next
    Else
        s=1:c=s
    End If
    r=r-2:s=s+2:c=s
    Next
Data 479667712,311470336,485697536,311699712,476292608,0,1976518785,1160267905,1171157123,1160267909,1171223529
Output:
           ___         ___   _________      ____________   _________      _______________   ___      ___
          /_ /|       /_ /| /_ /_ /_ /|    /_ /_ /_ /_ /| /_ /_ /_ /|    /_ /_ /_ /_ /_ /| /_ /|    /_ /|
         _[_]/       _[_]/ _[_][_][_]/_   _[_][_][_][_]/ _[_][_][_]/_    [_][_][_][_][_]/  [_]/_   _[_]/
        /_ /|       /_ /| /_ /|    /_ /| /_ /|          /_ /|    /_ /|       /_ /|          /_ /| /_ /|
       _[_]/       _[_]/ _[_]/____ [_]/ _[_]/____      _[_]/____ [_]/       _[_]/           [_]/__[_]/
      /_ /|       /_ /| /_ /_ /_ /|    /_ /_ /_ /|    /_ /_ /_ /|          /_ /|             /_ /_ /|
     _[_]/       _[_]/ _[_][_][_]/_   _[_][_][_]/    _[_][_][_]/_         _[_]/              [_][_]/
    /_ /|       /_ /| /_ /|    /_ /| /_ /|          /_ /|    /_ /|       /_ /|                /_ /|
   _[_]/____   _[_]/ _[_]/____ [_]/ _[_]/_______   _[_]/    _[_]/       _[_]/                _[_]/
  /_ /_ /_ /| /_ /| /_ /_ /_ /|    /_ /_ /_ /_ /| /_ /|    /_ /|       /_ /|                /_ /|
  [_][_][_]/  [_]/  [_][_][_]/     [_][_][_][_]/  [_]/     [_]/        [_]/                 [_]/

                       _________         ______         _________   ___      ______
                      /_ /_ /_ /|       /_ /_ /|       /_ /_ /_ /| /_ /|    /_ /_ /|
                     _[_][_][_]/_   ___ [_][_]/_   ___ [_][_][_]/ _[_]/ ___ [_][_]/_
                    /_ /|    /_ /| /_ /|    /_ /| /_ /|          /_ /| /_ /|    /_ /|
                   _[_]/____ [_]/ _[_]/_____[_]/  [_]/____      _[_]/ _[_]/     [_]/
                  /_ /_ /_ /|    /_ /_ /_ /_ /|    /_ /_ /|    /_ /| /_ /|
                 _[_][_][_]/_   _[_][_][_][_]/     [_][_]/_   _[_]/ _[_]/    ___
                /_ /|    /_ /| /_ /|    /_ /|          /_ /| /_ /| /_ /|    /_ /|
               _[_]/____ [_]/ _[_]/    _[_]/ _________ [_]/ _[_]/  [_]/____ [_]/
              /_ /_ /_ /|    /_ /|    /_ /| /_ /_ /_ /|    /_ /|    /_ /_ /|
              [_][_][_]/     [_]/     [_]/  [_][_][_]/     [_]/     [_][_]/

Locomotive Basic

10 mode 2:defint a-z
20 locate 1,25
30 print "Basic";
40 ' add some kerning so the characters will fit in 80 columns:
50 off(2)=1:off(4)=-2:off(5)=-4
60 for c=0 to 4
70 for y=7 to 0 step -1
80 for x=0 to 7
90 v=test(x+8*c,2*y)
100 plot x+8*c,2*y,0
110 if v>0 then gosub 180
120 next x
130 next y
140 next c
150 call &bb06  ' wait for key press
160 end
170 ' print pixel
180 xp=16*c+2*x+1+y+off(c+1)
190 yp=8-y
200 if xp>77 then return
210 locate xp,yp
220 print "//\";
230 locate xp,yp+1
240 print "\\/";
250 return
Output:
       ////////////\                                       ////\
       \////\\\\////\                                      \\\\/
       ////\/  ////\/   ////////\        ////////\     //////\       ////////\
      //////////\\\/    \\\\\////\    ////\\\\\\\/     \////\/    ////\\\\////\
     ////\\\\////\    //////////\/    \////////\       ////\/    ////\/   \\\\/
    ////\/  ////\/ ////\\\\////\/      \\\\\////\     ////\/    ////\/  ////\
 ////////////\\\/  \//////\\////\  //////////\\\/  ////////\    \////////\\\/
 \\\\\\\\\\\\/      \\\\\\/ \\\\/  \\\\\\\\\\/     \\\\\\\\/     \\\\\\\\/

TI-83 BASIC

Disp “ .....+ .....+ 
Disp “ +o+ooo +o+ooo 
Disp “   .o     .o
Disp “   .o   ...+.+
Disp “   +o   +ooooo 
Disp “ 
Disp “     BASIC

Replace . + o with 0x81,0x80,and 0x7F http://tibasicdev.wikidot.com/one-byte-tokens These can be found in the Catalog (2ND 0) menu, near the end

ZX Spectrum Basic

We have used an extended (non-ASCII) character in this example to produce an inverted space symbol (143 on the spectrum character table), for simplicity. We could substitute another character, and change the handler to cause a colour switch using a traditional space (ascii 32), but the output would still look the same. Fixed the error and removed the need for 2^z. 

  10 DIM b(5,5): REM our bigmap characters
  20 FOR l=1 TO 5: REM 5 characters
  30 FOR m=1 TO 5: REM 5 rows
  40 READ b(m,l)
  50 NEXT m
  60 NEXT l
  70 PAPER 0: BORDER 0: REM black background and border
  80 INK 2: REM our shadow will be red
  90 CLS
 100 LET r=8: REM shadow will start on row 8
 110 LET c=1: REM shadow will start at column 1
 120 GO SUB 2000: REM draw shadow
 130 INK 6: REM our foreground will be yellow
 140 LET r=9: REM foreground will start on row 9
 150 LET c=2: REM foreground will start on column 2
 160 GO SUB 2000: REM display the language name
 999 STOP
1000 REM convert to binary bigmap
1010 LET z=16
1020 IF t>=z THEN PRINT AT r+l-1,c+c1;CHR$ (143);: LET t=t-z: REM 143 is a block
1040 LET c1=c1+1: LET z=z/2
1050 IF z>=1 THEN GO TO 1020
1060 RETURN
2000 REM display the big letters
2010 FOR l=1 TO 5: LET c1=0: REM our 5 rows
2030 FOR m=1 TO 5: REM bigmap for each character
2040 LET t=b(l,m)
2050 GO SUB 1000
2060 LET c1=c1+1: REM PRINT " ";: REM space between each letter
2070 NEXT m
2080 NEXT l
2090 RETURN
9000 DATA 30,17,30,17,30: REM B
9010 DATA 14,17,31,17,17: REM A
9020 DATA 15,16,14,1,30: REM S
9030 DATA 31,4,4,4,31: REM I
9040 DATA 14,17,16,17,14: REM C

To me it does not work. So I bring my particular solution: 

5 PAPER 0: CLS 
10 LET d=0: INK 1: GO SUB 40
20 LET d=1: INK 6: GO SUB 40
30 STOP 
40 RESTORE 
50 FOR n=1 TO 5
60 READ a$
70 FOR j=1 TO LEN a$
80 PRINT AT n+7,j+5+d;
90 IF a$(j)="X" THEN PRINT CHR$ 143: REM Equivalent to 219 in ASCII extended for IBM PC
100 NEXT j
110 NEXT n
120 RETURN 
130 DATA "XXX  XXXX XXX X XXX"
140 DATA "X  X X  X X   X X  "
150 DATA "XXX  XXXX XXX X X  "
160 DATA "X  X X  X   X X X  "
170 DATA "XXX  X  X XXX X XXX"

Batch File

@echo off
for %%b in (
""
" /#######    ######  /########   ######  /##   /##"
"| ##__  ## /##__  ##|__  ##__/ /##__  ##| ##  | ##"
"| ##  | ##| ##  | ##   | ##   | ##  \__/| ##  | ##"
"| ####### | ########   | ##   | ##      | ########"
"| ##__  ##| ##__  ##   | ##   | ##      | ##__  ##"
"| ##  | ##| ##  | ##   | ##   | ##   /##| ##  | ##"
"| #######/| ##  | ##   | ##   |  ######/| ##  | ##"
"|_______/ |__/  |__/   |__/    \______/ |__/  |__/"
""
) do echo(%%~b
pause

Befunge

Befunge-93

0" &7&%h&'&%| &7&%7%&%&'&%&'&%&7&%"v
v"'%$%'%$%3$%$%7% 0%&7&%&7&(%$%'%$"<
>"%$%7%$%&%$%&'&%7%$%7%$%, '&+(%$%"v
v"+&'&%+('%$%$%'%$%$%$%$%$%$%$%'%$"<
>"(%$%$%'%$%$%( %$+(%&%$+(%&%$+(%&"v
v"(; $%$%(+$%&%(+$%$%'%$%+&%$%$%$%"<
? ";(;(+(+$%+(%&(;(3%$%&$ 7`+( ":v >
^v!:-1<\,:g7+*63%4 \/_#4:_v#:-*84_$@
$_\:,\^                   >55+,$:^:$
Output:
  __                _____
 /\ \____  ______  /\  __\ __  __  ______  ______  ______
 \ \  __ \/\  __ \ \_\ \__/\ \ \ \/\  __ \/\  __ \/\  __ \
  \ \ \_\ \ \  __/_/\__  _\ \ \_\ \ \ \ \ \ \ \_\ \ \  __/_
   \ \_____\ \_____\/_/\ \/\ \_____\ \_\ \_\ \____ \ \_____\
    \/_____/\/_____/  \ \_\ \/_____/\/_/\/_/\/\_____\/_____/
                       \/_/                  \/_____/

Befunge-98

Bit of a long one,but it works and it does something other than taking strings and simply copying to STDOUT. (It adds line offset to those strings,and the strings are encoded with numbers just because.)

Works with: CCBI version 2.1
v THE DATA IMAGE.(totally useless after loading into stack)
>89                                   v Made by gamemanj
v0000122010000000000022201220000020000< For rosettacode
>9                                    v The 'image' is upsidedown
v2220100010002220101000101000000000000< The 3d offset isn't applied on this
>9                                    v and it's encoded weirdly
v1010122012001010101022201220000010000< Is that enough decoding needed
>9                                    v for the '3d' ascii requirement?
v2220100010001010222010101000000010000< Huh.(sees Batch) I think so.
>9                                    v 0:blank
v1000122012200000000022201220000010000< 1:\
>9                                    v 2:-
v                                 p000< 9:newline
>:9-v Check for 9:Newline               8:end
   v_v      (note that cell 0,0 isn't ever used after the first tick!)
 no   yes   |    |   >" ",v
     >$55+,00g1+:00p:|: -1< Newline With Spacing Encoder
^  v#               $<                             
   :
   8 check for end
 no-yes
  v_v
    >< make the program pause for the user forever.Ik,it's stupid

    Numeric Decoder \/
  >:1-v
     v_vCheck for 1 '\'
   NO: "YES
     2 \
     - " 
    v_  >v
    "    "
^        -
    "    "
^ $,<  < < (code path reuse here,all 3 end in ,$ so I merged them)
Output:

 \   \-- \--         --- \--     \    
  --- \   \   \ \ --- \ \ \       \    
   \ \ \-- \-  \ \ \ \ --- \--     \    
    --- \   \   --- \ \   \ \            
         \-- \           --- \--     -

Binary Lambda Calculus

Using the fact that an asterisk at the start of a program copies the rest to stdout: 

*      ____
     /\  _`\    __ 
     \ \ \L\ \ /\_\    ___      __     _ __   __  __
      \ \  _ <'\/\ \ /' _ `\  /'__`\  /\`'__\/\ \/\ \
       \ \ \L\ \\ \ \/\ \/\ \/\ \L\.\_\ \ \/ \ \ \_\ \
        \ \____/ \ \_\ \_\ \_\ \__/.\_\\ \_\  \/`____ \
         \/___/   \/_/\/_/\/_/\/__/\/_/ \/_/   `/___/> \
    __                           __          __   /\___/
   /\ \                         /\ \        /\ \  \/__/
   \ \ \         __      ___ ___\ \ \____   \_\ \     __
    \ \ \  __  /'__`\  /' __` __`\ \ '__`\  /'_` \  /'__`\
     \ \ \L\ \/\ \L\.\_/\ \/\ \/\ \ \ \L\ \/\ \L\ \/\ \L\.\_
      \ \____/\ \__/.\_\ \_\ \_\ \_\ \_,__/\ \___,_\ \__/.\_\
       \/___/  \/__/\/_/\/_/\/_/\/_/\/___/  \/__,_ /\/__/\/_/
 ____              ___                    ___                  
/\  _`\           /\_ \                  /\_ \
\ \ \/\_\     __  \//\ \     ___   __  __\//\ \    __  __    ____
 \ \ \/_/_  /'__`\  \ \ \   /'___\/\ \/\ \ \ \ \  /\ \/\ \  /',__\
  \ \ \L\ \/\ \L\.\_ \_\ \_/\ \__/\ \ \_\ \ \_\ \_\ \ \_\ \/\__, `\
   \ \____/\ \__/.\_\/\____\ \____\\ \____/ /\____\\ \____/\/\____/
    \/___/  \/__/\/_/\/____/\/____/ \/___/  \/____/ \/___/  \/___/

Brainf***

Coming up with decent 3D font was honestly the hardest part. 

++++[>++++>++<[>>++>+++>++++++>    ++++++<<<<<-]<-]>>++>..>->---->
-...[<]<+++[>++++[>>...<<-]<-]>    >>..>>>.....<<<..>>>...[<]++[>>
.....>>>...<<<<<-]>.>.>.>.<<..>    >.[<]<+++++[>++++[>>.<<-]<-]>>>
..>>>...[<]+++++[>>..<<-]+++>>.    >.<..>>>...<.[[>]<.<.<<..>>.>..
<<<.<<-]+++>.>.>>.<<.>>.<<..>>.    >....<<<.>>>...<<<..>>>...<<<.>
>>......<<.>.>..<.<<..>>>..<<<.    .>>>....<.<<..>>.>..<<.[[>]<<.>
..<<<...>>>.<.<<<<-]+++>.>..>>.    <<.>>.<<...>>>..<<<.>>..<<..>>.
<.<.>>>..<..>...<<<...>>.<<.>>>    .<<.>>.<<.<..>>.<.<.>>>.<<<..>>
.>.<<<...>>>..<.>.<<.>.>..<.<..    >>.<<.>.>..<.<..>>.<<.>.>..<.<.
<<.>...>>.<<.>>.<<..>>.<.>.<<.>    >..<<...>.>>..<<..>>...<.<<...>
>..<<..>>..<<...>.<.>>.<<..>>..    <<..>>.>.<<.<[[>]<<<<.>>.<.>>..
<<.<..<<-]>.>....>>.<<.>>.<<..>    >.>.<.<<.>>..<<..>>.<<...>.>.<<
..>>>.<<<....>>..<<..>>..<<..>>    ..<<.>>.<<..>>..<<..>>.<<<.>...
..>>.<<.>>.>......<..>..<.<<..>    >.<<.>>.>...<<.>.>..<..>..<..>.
.<..<<.>>.>..<..>..<.<<<.>.....    .>>.<.>>......<<..>>..<<.<...>>
.<.>>..<<.>.<.>>..<<..>>..<<..>    >..<<.<.>>.<.>>..<<..>>..<<.<<.
Output:
  ___                                      _____  ___     ___     ___
 /\  \                      ___           /  ___\_\  \__ _\  \__ _\  \__ 
 \ \  \____ ___  ___ ______/\__\  __  ____\  \__/\__   _\\__   _\\__   _\
  \ \   __ \\  \/ __\\___   \ _/_/  \/ _  \_   __\_/\__\//_/\__\//_/\__\/
   \ \  \/\ \\   /__//___\   \\  \\   / \  \\  \_/ \/__/   \/__/   \/__/  
    \ \  \_\ \\  \   /\  _    \\  \\  \\ \  \\  \
     \ \______\\__\  \ \___/\__\\__\\__\\ \__\\__\
      \/______//__/   \/__/\/__//__//__/ \/__//__/

C

3D enough?

#include <stdio.h>
const char*s = "  _____\n /____/\\\n/  ___\\/\n\\  \\/__/\n \\____/";
int main(){ puts(s); return 0; }
Output:
  _____
 /____/\
/  ___\/
\  \/__/
 \____/

C#

using System;
using System.Text;

namespace Language_name_in_3D_ascii
{
    public class F5
    {
        char[] z = { ' ', ' ', '_', '/', };
        long[,] f ={
            {87381,87381,87381,87381,87381,87381,87381,},
            {349525,375733,742837,742837,375733,349525,349525,},
            {742741,768853,742837,742837,768853,349525,349525,},
            {349525,375733,742741,742741,375733,349525,349525,},
            {349621,375733,742837,742837,375733,349525,349525,},
            {349525,375637,768949,742741,375733,349525,349525,},
            {351157,374101,768949,374101,374101,349525,349525,},
            {349525,375733,742837,742837,375733,349621,351157,},
            {742741,768853,742837,742837,742837,349525,349525,},
            {181,85,181,181,181,85,85,},
            {1461,1365,1461,1461,1461,1461,2901,},
            {742741,744277,767317,744277,742837,349525,349525,},
            {181,181,181,181,181,85,85,},
            {1431655765,3149249365L,3042661813L,3042661813L,3042661813L,1431655765,1431655765,},
            {349525,768853,742837,742837,742837,349525,349525,},
            {349525,375637,742837,742837,375637,349525,349525,},
            {349525,768853,742837,742837,768853,742741,742741,},
            {349525,375733,742837,742837,375733,349621,349621,},
            {349525,744373,767317,742741,742741,349525,349525,},
            {349525,375733,767317,351157,768853,349525,349525,},
            {374101,768949,374101,374101,351157,349525,349525,},
            {349525,742837,742837,742837,375733,349525,349525,},
            {5592405,11883957,11883957,5987157,5616981,5592405,5592405,},
            {366503875925L,778827027893L,778827027893L,392374737749L,368114513237L,366503875925L,366503875925L,},
            {349525,742837,375637,742837,742837,349525,349525,},
            {349525,742837,742837,742837,375733,349621,375637,},
            {349525,768949,351061,374101,768949,349525,349525,},
            {375637,742837,768949,742837,742837,349525,349525,},
            {768853,742837,768853,742837,768853,349525,349525,},
            {375733,742741,742741,742741,375733,349525,349525,},
            {192213,185709,185709,185709,192213,87381,87381,},
            {1817525,1791317,1817429,1791317,1817525,1398101,1398101,},
            {768949,742741,768853,742741,742741,349525,349525,},
            {375733,742741,744373,742837,375733,349525,349525,},
            {742837,742837,768949,742837,742837,349525,349525,},
            {48053,23381,23381,23381,48053,21845,21845,},
            {349621,349621,349621,742837,375637,349525,349525,},
            {742837,744277,767317,744277,742837,349525,349525,},
            {742741,742741,742741,742741,768949,349525,349525,},
            {11883957,12278709,11908533,11883957,11883957,5592405,5592405,},
            {11883957,12277173,11908533,11885493,11883957,5592405,5592405,},
            {375637,742837,742837,742837,375637,349525,349525,},
            {768853,742837,768853,742741,742741,349525,349525,},
            {6010197,11885397,11909973,11885397,6010293,5592405,5592405,},
            {768853,742837,768853,742837,742837,349525,349525,},
            {375733,742741,375637,349621,768853,349525,349525,},
            {12303285,5616981,5616981,5616981,5616981,5592405,5592405,},
            {742837,742837,742837,742837,375637,349525,349525,},
            {11883957,11883957,11883957,5987157,5616981,5592405,5592405,},
            {3042268597L,3042268597L,3042661813L,1532713813,1437971797,1431655765,1431655765,},
            {11883957,5987157,5616981,5987157,11883957,5592405,5592405,},
            {11883957,5987157,5616981,5616981,5616981,5592405,5592405,},
            {12303285,5593941,5616981,5985621,12303285,5592405,5592405,}
            };

        private F5(string s)
        {
            StringBuilder[] o = new StringBuilder[7];
            for (int i = 0; i < 7; i++) o[i] = new StringBuilder();
            for (int i = 0, l = s.Length; i < l; i++)
            {
                int c = s[i];
                if (65 <= c && c <= 90) c -= 39;
                else if (97 <= c && c <= 122) c -= 97;
                else c = -1;
                long[] d = new long[7];
                Buffer.BlockCopy(f, (++c * sizeof(long) * 7), d, 0, 7 * sizeof(long));
                for (int j = 0; j < 7; j++)
                {
                    StringBuilder b = new StringBuilder();
                    long v = d[j];
                    while (v > 0)
                    {
                        b.Append(z[(int)(v & 3)]);
                        v >>= 2;
                    }
                    char[] charArray = b.ToString().ToCharArray();
                    Array.Reverse(charArray);
                    o[j].Append(new string(charArray));
                }
            }
            for (int i = 0; i < 7; i++)
            {
                for (int j = 0; j < 7 - i; j++)
                    System.Console.Write(' ');
                System.Console.WriteLine(o[i]);
            }
        }

        public static void Main(string[] args)
        {
            new F5(args.Length > 0 ? args[0] : "C sharp");
        }
    }
}

Output: 

         _/_/_/                     _/
      _/                   _/_/_/  _/_/_/      _/_/_/  _/  _/_/  _/_/_/
     _/                 _/_/      _/    _/  _/    _/  _/_/      _/    _/
    _/                     _/_/  _/    _/  _/    _/  _/        _/    _/
     _/_/_/           _/_/_/    _/    _/    _/_/_/  _/        _/_/_/
                                                             _/
                                                            _/

C++

#include <windows.h>
#include <iostream>

//--------------------------------------------------------------------------------------------------
using namespace std;

//--------------------------------------------------------------------------------------------------
int main(int argc, char* argv[])
{
	cout << 
		"                        ______          ______  " << endl <<
		"        _____     _____|\\     \\   _____|\\     \\ " << endl <<
		"   _____\\    \\_  /     / |     | /     / |     |" << endl <<
		"  /     /|     ||      |/     /||      |/     /|" << endl <<
		" /     / /____/||      |\\____/ ||      |\\____/ |" << endl <<
		"|     | |____|/ |\\     \\    | / |\\     \\    | / " << endl <<
		"|     |  _____  | \\     \\___|/  | \\     \\___|/  " << endl <<
		"|\\     \\|\\    \\ |  \\     \\      |  \\     \\      " << endl <<
		"| \\_____\\|    |  \\  \\_____\\      \\  \\_____\\     " << endl <<
		"| |     /____/|   \\ |     |       \\ |     |     " << endl <<
		" \\|_____|    ||    \\|_____|        \\|_____|     " << endl <<
		"        |____|/                                 ";

	cout << endl << endl << endl;

	system( "pause" );
	return 0;
}
//--------------------------------------------------------------------------------------------------
Output:
                        ______          ______
        _____     _____|\     \   _____|\     \
   _____\    \_  /     / |     | /     / |     |
  /     /|     ||      |/     /||      |/     /|
 /     / /____/||      |\____/ ||      |\____/ |
|     | |____|/ |\     \    | / |\     \    | /
|     |  _____  | \     \___|/  | \     \___|/
|\     \|\    \ |  \     \      |  \     \
| \_____\|    |  \  \_____\      \  \_____\
| |     /____/|   \ |     |       \ |     |
 \|_____|    ||    \|_____|        \|_____|
        |____|/

Another solution: 

// @author Martin Ettl (http://www.martinettl.de)
// @date   2013-07-26
// A program to print the letters 'CPP' in 3D ASCII-art.

#include <iostream>
#include <string>

int main()
{
    std::string strAscii3D =
        "  /$$$$$$  /$$$$$$$  /$$$$$$$ \n"
        " /$$__  $$| $$__  $$| $$__  $$\n"
        "| $$  \\__/| $$  \\ $$| $$  \\ $$\n"
        "| $$      | $$$$$$$/| $$$$$$$/\n"
        "| $$      | $$____/ | $$____/ \n"
        "| $$    $$| $$      | $$      \n"
        "|  $$$$$$/| $$      | $$      \n"
        " \\______/ |__/      |__/  \n";

    std::cout << "\n" << strAscii3D << std::endl;
    
    return 0;
}
Output:
   /$$$$$$  /$$$$$$$  /$$$$$$$ 
 /$$__  $$| $$__  $$| $$__  $$
| $$  \__/| $$  \ $$| $$  \ $$
| $$      | $$$$$$$/| $$$$$$$/
| $$      | $$____/ | $$____/ 
| $$    $$| $$      | $$      
|  $$$$$$/| $$      | $$      
 \______/ |__/      |__/

Clojure

Library: clj-figlet
(use 'clj-figlet.core)
(println 
  (render-to-string 
    (load-flf "ftp://ftp.figlet.org/pub/figlet/fonts/contributed/larry3d.flf")
    "Clojure"))
Output:
 ____       ___
/\  _`\    /\_ \              __
\ \ \/\_\  \//\ \      ___   /\_\     __  __   _ __     __
 \ \ \/_/_   \ \ \    / __`\ \/\ \   /\ \/\ \ /\`'__\ /'__`\
  \ \ \L\ \   \_\ \_ /\ \L\ \ \ \ \  \ \ \_\ \\ \ \/ /\  __/
   \ \____/   /\____\\ \____/ _\ \ \  \ \____/ \ \_\ \ \____\
    \/___/    \/____/ \/___/ /\ \_\ \  \/___/   \/_/  \/____/
                             \ \____/
                              \/___/

COBOL

This displays 'COBOL' in 3D with a shadow effect. The font is 'Slant Relief' from here.

Works with: OpenCOBOL
       IDENTIFICATION DIVISION.
       PROGRAM-ID. cobol-3d.

       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01  cobol-area.
           03  cobol-text-data PIC X(1030) VALUE "________/\\\\\\\\\____
      -        "____/\\\\\________/\\\\\\\\\\\\\__________/\\\\\________
      -        "/\\\_____________         _____/\\\////////_______/\\\//
      -        "/\\\_____\/\\\/////////\\\______/\\\///\\\_____\/\\\____
      -        "_________         ___/\\\/______________/\\\/__\///\\\__
      -        "_\/\\\_______\/\\\____/\\\/__\///\\\___\/\\\____________
      -        "_         __/\\\_______________/\\\______\//\\\__\/\\\\\
      -        "\\\\\\\\\____/\\\______\//\\\__\/\\\_____________       
      -      "  _\/\\\______________\/\\\_______\/\\\__\/\\\/////////\\\
      -        "__\/\\\_______\/\\\__\/\\\_____________         _\//\\\_
      -        "____________\//\\\______/\\\___\/\\\_______\/\\\__\//\\\
      -        "______/\\\___\/\\\_____________         __\///\\\_______
      -        "_____\///\\\__/\\\_____\/\\\_______\/\\\___\///\\\__/\\\
      -        "_____\/\\\_____________         ____\////\\\\\\\\\_____\
      -        "///\\\\\/______\/\\\\\\\\\\\\\/______\///\\\\\/______\/\
      -        "\\\\\\\\\\\\\\_         _______\/////////________\/////_
      -        "_______\/////////////__________\/////________\//////////
      -        "/////__" *> " Sorry for the syntax highlighting.
               .
           03  cobol-text-table REDEFINES cobol-text-data.
               05  cobol-text  PIC X(103) OCCURS 10 TIMES.

       01  i                   PIC 99.
       01  j                   PIC 9(4).

       PROCEDURE DIVISION.
           *> Display 'COBOL' line-by-line applying a shadow effect.
           PERFORM VARYING i FROM 1 BY 1 UNTIL 10 < i
               MOVE 1 TO j
               PERFORM UNTIL 103 < j
                   *> When the top of a letter  meets the right edge,
                   *> take care to shadow only the wall ('/').
                   IF cobol-text (i) (j:4) = "\\\/"
                       DISPLAY cobol-text (i) (j:3) AT LINE i COL j
                           WITH FOREGROUND-COLOR 7, HIGHLIGHT
                           
                       ADD 3 TO j
                       DISPLAY cobol-text (i) (j:1) AT LINE i COL j
                           WITH FOREGROUND-COLOR 0, HIGHLIGHT

                       ADD 1 TO j
                           
                       EXIT PERFORM CYCLE
                   END-IF
                       
                   *> Apply shadows to the walls, base and the char
                   *> before the base.
                   IF cobol-text (i) (j:1) = "/" 
                          OR cobol-text (i) (FUNCTION SUM(j, 1):1) = "/"
                          OR cobol-text (i) (FUNCTION SUM(j, 1):2)
                              = "\/"
                       DISPLAY cobol-text (i) (j:1)  AT LINE i COL j
                           WITH FOREGROUND-COLOR 0, HIGHLIGHT
                   *> Do not apply a shadow to anything else.
                   ELSE
                       DISPLAY cobol-text (i) (j:1) AT LINE i COL j
                           WITH FOREGROUND-COLOR 7 , HIGHLIGHT
                   END-IF

                   ADD 1 TO j
               END-PERFORM
           END-PERFORM

           *> Prompt the user so that they have a chance to see the
           *> ASCII art, as sometimes the screen data is overwritten by
           *> what was on the console before starting the program.
           DISPLAY "Press enter to stop appreciating COBOL in 3D."
               AT LINE 11 COL 1
           ACCEPT i AT LINE 11 COL 46

           GOBACK
           .
Output:

(note

the shadow effect is quite faint on this site):
 _______'''_/'''\\\\\\\\\_______'''_/'''\\\\\_______'''_/'''\\\\\\\\\\\\\_________'''_/'''\\\\\_______'''_/'''\\\_____________        
  ____'''_/'''\\\'''////////'''______'''_/'''\\\'''///'''\\\____'''_\/'''\\\'''/////////'''\\\_____'''_/'''\\\'''///'''\\\____'''_\/'''\\\_____________       
   __'''_/'''\\\'''/'''_____________'''_/'''\\\'''/'''_'''_\///'''\\\__'''_\/'''\\\______'''_\/'''\\\___'''_/'''\\\/_'''_\///'''\\\__'''_\/'''\\\_____________      
    _'''_/'''\\\______________'''_/'''\\\_____'''_\//'''\\\_'''_\/'''\\\\\\\\\\\\\\___'''_/'''\\\_____'''_\/'''/\\\_'''_\/'''\\\_____________     
     '''_\/'''\\\_____________'''_\/'''\\\______'''_\/'''\\\_'''_\/'''\\\'''/////////'''\\\_'''_\/'''\\\______'''_\/'''\\\_'''_\/'''\\\_____________    
      '''_\//'''\\\____________'''_\//'''\\\_____'''_/'''\\\__'''_\/'''\\\______'''_\/'''\\\_'''_\//'''\\\_____'''_/'''\\\__'''_\/'''\\\_____________   
       _'''_\///'''\\\___________'''_\///'''\\\_'''_/'''\\\____'''_\/'''\\\______'''_\/'''\\\__'''_\///'''\\\_'''_/'''\\\____'''_\/'''\\\_____________  
        ___'''_\////'''\\\\\\\\\____'''_\///'''\\\\\/_____'''_\/'''\\\\\\\\\\\\\'''/'''_____'''_\///'''\\\\\'''/'''_____'''_\/'''\\\\\\\\\\\\\\\_ 
         ______'''_\/////////'''_______'''_\/////'''_______'''_\/////////////'''_________'''_\/////'''_______'''_\///////////////'''__
 Press enter to stop appreciating COBOL in 3D.

Common Lisp

Library: cl-ppcre
(ql:quickload :cl-ppcre)
(defvar txt 
"
 xxxx    xxxx   x    x  x    x   xxxx   x    x       x      x   xxxx   xxxxx  
x    x  x    x  xx  xx  xx  xx  x    x  xx   x       x         x    x  x    x 
x       x    x  x xx x  x xx x  x    x  x x  x       x      x  xxx     x    x 
x       x    x  x    x  x    x  x    x  x  x x       x      x     xxx  xxxxx  
x    x  x    x  x    x  x    x  x    x  x   xx       x      x  x    x  x      
 xxxx    xxxx   x    x  x    x   xxxx   x    x       xxxxx  x   xxxx   x     
"
)
(princ (cl-ppcre:regex-replace-all " " (cl-ppcre:regex-replace-all "x" txt "_/") "  " ))
Output:
  _/_/_/_/        _/_/_/_/      _/        _/    _/        _/      _/_/_/_/      _/        _/              _/            _/      _/_/_/_/      _/_/_/_/_/    
_/        _/    _/        _/    _/_/    _/_/    _/_/    _/_/    _/        _/    _/_/      _/              _/                  _/        _/    _/        _/  
_/              _/        _/    _/  _/_/  _/    _/  _/_/  _/    _/        _/    _/  _/    _/              _/            _/    _/_/_/          _/        _/  
_/              _/        _/    _/        _/    _/        _/    _/        _/    _/    _/  _/              _/            _/          _/_/_/    _/_/_/_/_/    
_/        _/    _/        _/    _/        _/    _/        _/    _/        _/    _/      _/_/              _/            _/    _/        _/    _/            
  _/_/_/_/        _/_/_/_/      _/        _/    _/        _/      _/_/_/_/      _/        _/              _/_/_/_/_/    _/      _/_/_/_/      _/

ContextFree

startshape START

shape START {
	loop i = 6 [y -1 x -1 z 10] NAME [b 1-((i+1)*0.11)]
}

shape NAME {	
	C [ x 34 z 1]
	O [ x 46 z 2]
	N [ x 64 z 3]
	T [ x 85 z 4]
	E [ x 95 z 5]
	X [ x 106 z 6]
	T [ x 125 z 7]
	
	HYPHEN[x 135]

	F [ x 145 z 8]
	R [ x 158 z 9]
	E [ x 175 z 10]
	E [ x 188 z 11]
	

}

shape C {
	ARCL [ y 12 flip 90 ]
	ARCL [ y 12 r 180 ]
}


shape E {
	LINE [ s 0.9 ]
	LINE [ s 0.9 -1 y 24 ]
	LINE [ s 0.4 r -90 y 0 ]
	LINE [ s 0.4 r -90 y 12 ]
	LINE [ s 0.4 r -90 y 24 ]
}

shape F {	
	LINE [ s 0.9 -1 y 24 ]
	LINE [ s 0.4 r -90 y 12 ]
	LINE [ s 0.4 r -90 y 24 ]
}


shape M {
	LINE [ y 24 r 180 ]
	LINE [ y 24 r  -160 s 0.75 ]
	LINE [ y 24 x 12 r 160 s 0.75 ]
	LINE [ y 24 x 12 r 180 ]
}

shape N {
	LINE [ y 24 r 180 ]
	LINE [ y 24 r  -160 ]
	LINE [ y 24 x 9 r 180 ]
}

shape O {
	ARCL [ y 12 flip 90]
	ARCL [ y 12 r 180 ]
	ARCL [ y 12 x 14 r 180 flip 90]
	ARCL [ y 12 x 14 ]
}

shape R {	
	LINE [ s 0.9 -1 y 24 ]
	LINE [ s 0.4 r -90 y 12 ]
	LINE [ s 0.4 r -90 y 24 ]
	LINE [ y 12 r  -140 s 0.65 ]

	ARCL [ y 18 x 12 r 180 flip 90 s 0.8 0.5]
	ARCL [ y 18 x 12 s 0.8 0.5 ]

}

shape T {	
	LINE [ s 0.9 -1 y 24 ]
	LINE [ s 0.4 r -90 y 24 ]
	LINE [ s 0.4 r 90 y 24 ]
}

shape X {
	LINE [ x 8 y 24 r 160 ]
	LINE [ y 24 r  -160 ]
}

shape HYPHEN{
	SQUARE[y 11.5  s 4 0.5]
}

shape LINE {
	TRIANGLE [[ s 1 30 y 0.26 ]]

}

shape ARCL {
	SQUARE [ ]
	ARCL [ size 0.97 y 0.55 r 1.5 ]
}
Output:

Output Image

D

This generates a single image ASCII stereogram. 

// Derived from AA3D - ASCII art stereogram generator
// by Jan Hubicka and Thomas Marsh
// (GNU General Public License)
// http://aa-project.sourceforge.net/aa3d/
// http://en.wikipedia.org/wiki/ASCII_stereogram

import std.stdio, std.string, std.random;

immutable image = "
                  111111111111111
                  1111111111111111
                   11111       1111
                   11111        1111
                   11111        1111
                   11111        1111
                   11111        1111
                   11111       1111
                  1111111111111111
                  111111111111111

";

void main() {
    enum int width = 50;
    immutable text = "DLanguage";
    enum int skip = 12;

    char[65536 / 2] data;

    foreach (y, row; image.splitLines()) {
        immutable int shift = uniform(0, int.max);
        bool l = false;

        foreach (x; 0 .. width) {
            int s;
            if (!l && x > skip) {
                s = (x < row.length) ? row[x] : '\n';
                if (s == ' ') {
                    s = 0;
                } else if (s == '\n') {
                    s = 0;
                    l = true;
                } else if (s >= '0' && s <= '9') {
                    s = '0' - s;
                } else
                    s = -2;
            } else
                s = 0;

            s += skip;
            s = x - s;
            s = (s < 0) ? text[(x + shift) % text.length] : data[s];
            data[x] = cast(char)s;
            write(data[x]);
        }

        writeln();
    }
}
Output:
nguageDLangunguageDLangunguageDLangunguageDLangung
DLanguageDLaDLangugeDLaDLangugeDLLaDLangugeDLLaDLa
nguageDLangunguageLangunguageLanguunguageLanguungu
LanguageDLanLanguagDLanLLanguagLanLLLanguagLanLLLa
eDLanguageDLeDLangugeDLeeDLangugDLeeeDLangugDLeeeD
guageDLanguaguageDLnguagguageDLnuaggguageDLnuagggu
LanguageDLanLanguagDLanLLanguagDanLLLanguagDanLLLa
nguageDLangunguageDangunnguageDagunnnguageDagunnng
LanguageDLanLanguagDLanLLanguagLanLLLanguagLanLLLa
nguageDLangunguageLangunguageLanguunguageLanguungu
geDLanguageDgeDLanuageDgeDLanuageeDgeDLanuageeDgeD
guageDLanguaguageDLanguaguageDLanguaguageDLanguagu

Dart

void main(){
 print("""

 XXX       XX       XXX     XXXX
  X   X    X    X     X    X      X
   X   X    XXXX      XXX        X
    XXX      X    X      X   X      X
  """.replaceAll('X','_/'));
}
Output:

 _/_/_/       _/_/       _/_/_/     _/_/_/_/
  _/   _/    _/    _/     _/    _/      _/
   _/   _/    _/_/_/_/      _/_/_/        _/
    _/_/_/      _/    _/      _/   _/      _/

Delphi

Library: System.SysUtils
Translation of: Java
program Write_language_name_in_3D_ASCII;

{$APPTYPE CONSOLE}

uses
  System.SysUtils;

const
  z: TArray<char> = [' ', ' ', '_', '/'];
  f: TArray<TArray<Cardinal>> = [[87381, 87381, 87381, 87381, 87381, 87381,
    87381], [349525, 375733, 742837, 742837, 375733, 349525, 349525], [742741,
    768853, 742837, 742837, 768853, 349525, 349525], [349525, 375733, 742741,
    742741, 375733, 349525, 349525], [349621, 375733, 742837, 742837, 375733,
    349525, 349525], [349525, 375637, 768949, 742741, 375733, 349525, 349525], [351157,
    374101, 768949, 374101, 374101, 349525, 349525], [349525, 375733, 742837,
    742837, 375733, 349621, 351157], [742741, 768853, 742837, 742837, 742837,
    349525, 349525], [181, 85, 181, 181, 181, 85, 85], [1461, 1365, 1461, 1461,
    1461, 1461, 2901], [742741, 744277, 767317, 744277, 742837, 349525, 349525],
    [181, 181, 181, 181, 181, 85, 85], [1431655765, 3149249365, 3042661813,
    3042661813, 3042661813, 1431655765, 1431655765], [349525, 768853, 742837,
    742837, 742837, 349525, 349525], [349525, 375637, 742837, 742837, 375637,
    349525, 349525], [349525, 768853, 742837, 742837, 768853, 742741, 742741], [349525,
    375733, 742837, 742837, 375733, 349621, 349621], [349525, 744373, 767317,
    742741, 742741, 349525, 349525], [349525, 375733, 767317, 351157, 768853,
    349525, 349525], [374101, 768949, 374101, 374101, 351157, 349525, 349525], [349525,
    742837, 742837, 742837, 375733, 349525, 349525], [5592405, 11883957,
    11883957, 5987157, 5616981, 5592405, 5592405], [366503875925, 778827027893,
    778827027893, 392374737749, 368114513237, 366503875925, 366503875925], [349525,
    742837, 375637, 742837, 742837, 349525, 349525], [349525, 742837, 742837,
    742837, 375733, 349621, 375637], [349525, 768949, 351061, 374101, 768949,
    349525, 349525], [375637, 742837, 768949, 742837, 742837, 349525, 349525], [768853,
    742837, 768853, 742837, 768853, 349525, 349525], [375733, 742741, 742741,
    742741, 375733, 349525, 349525], [192213, 185709, 185709, 185709, 192213,
    87381, 87381], [1817525, 1791317, 1817429, 1791317, 1817525, 1398101,
    1398101], [768949, 742741, 768853, 742741, 742741, 349525, 349525], [375733,
    742741, 744373, 742837, 375733, 349525, 349525], [742837, 742837, 768949,
    742837, 742837, 349525, 349525], [48053, 23381, 23381, 23381, 48053, 21845,
    21845], [349621, 349621, 349621, 742837, 375637, 349525, 349525], [742837,
    744277, 767317, 744277, 742837, 349525, 349525], [742741, 742741, 742741,
    742741, 768949, 349525, 349525], [11883957, 12278709, 11908533, 11883957,
    11883957, 5592405, 5592405], [11883957, 12277173, 11908533, 11885493,
    11883957, 5592405, 5592405], [375637, 742837, 742837, 742837, 375637, 349525,
    349525], [768853, 742837, 768853, 742741, 742741, 349525, 349525], [6010197,
    11885397, 11909973, 11885397, 6010293, 5592405, 5592405], [768853, 742837,
    768853, 742837, 742837, 349525, 349525], [375733, 742741, 375637, 349621,
    768853, 349525, 349525], [12303285, 5616981, 5616981, 5616981, 5616981,
    5592405, 5592405], [742837, 742837, 742837, 742837, 375637, 349525, 349525],
    [11883957, 11883957, 11883957, 5987157, 5616981, 5592405, 5592405], [3042268597,
    3042268597, 3042661813, 1532713813, 1437971797, 1431655765, 1431655765], [11883957,
    5987157, 5616981, 5987157, 11883957, 5592405, 5592405], [11883957, 5987157,
    5616981, 5616981, 5616981, 5592405, 5592405], [12303285, 5593941, 5616981,
    5985621, 12303285, 5592405, 5592405]];

function ReverseString(s: string): string;
var
  i, len: integer;
begin
  len := s.Length;
  SetLength(Result, len);
  for i := 1 to len do
    Result[len - i + 1] := s[i];
end;

procedure F5(s: ansistring);
begin
  var o: TArray<TStringBuilder>;
  SetLength(o, 7);
  for var i := 0 to High(o) do
    o[i] := TStringBuilder.Create;

  var l := length(s);
  for var i := 1 to l do
  begin
    var c: Integer := ord(s[i]);
    if c in [65..90] then
      c := c - 39
    else if c in [97..122] then
      c := c - 97
    else
      c := -1;

    inc(c);
    var d: TArray<Cardinal> := f[c];
    for var j := 0 to 6 do
    begin
      var b := TStringBuilder.Create;
      var v := d[j];

      while v > 0 do
      begin
        b.Append(z[Trunc(v and 3)]);
        v := v shr 2;
      end;
      o[j].Append(ReverseString(b.ToString));
      b.Free;
    end;
  end;
  for var i := 0 to 6 do
  begin
    for var j := 0 to 6 - i do
      write(' ');
    writeln(o[i].ToString);
  end;

  for var i := 0 to High(o) do
    o[i].Free;
end;

begin
  F5('Delphi');
  F5('Thanks Java');
  F5('guy');
  readln;
end.
Output:
       _/_/_/             _/            _/        _/
      _/    _/   _/_/    _/  _/_/_/    _/_/_/
     _/    _/ _/_/_/_/  _/  _/    _/  _/    _/  _/
    _/    _/ _/        _/  _/    _/  _/    _/  _/
   _/_/_/     _/_/_/  _/  _/_/_/    _/    _/  _/
                         _/
                        _/
       _/_/_/_/_/  _/                            _/                                 _/
          _/      _/_/_/      _/_/_/  _/_/_/    _/  _/      _/_/_/                 _/    _/_/_/  _/      _/    _/_/_/
         _/      _/    _/  _/    _/  _/    _/  _/_/      _/_/                     _/  _/    _/  _/      _/  _/    _/
        _/      _/    _/  _/    _/  _/    _/  _/  _/        _/_/           _/    _/  _/    _/    _/  _/    _/    _/
       _/      _/    _/    _/_/_/  _/    _/  _/    _/  _/_/_/               _/_/      _/_/_/      _/        _/_/_/



        _/_/_/  _/    _/  _/    _/
     _/    _/  _/    _/  _/    _/
    _/    _/  _/    _/  _/    _/
     _/_/_/    _/_/_/    _/_/_/
        _/                  _/
     _/_/              _/_/

Elixir

defmodule ASCII3D do
  def decode(str) do
    Regex.scan(~r/(\d+)(\D+)/, str)
    |> Enum.map_join(fn[_,n,s] -> String.duplicate(s, String.to_integer(n)) end)
    |> String.replace("B", "\\")        # Backslash
  end
end

data = "1 12_4 2_1\n1/B2 9_1B2 1/2B 3 2_18 2_1\nB2 B8_1/ 3 B2 1/B_B4 2_6 2_2 1/B_B6 4_1
3 B7_3 4 B2/_2 1/2B_1_2 1/B_B B2/_4 1/ 3_1B\n 2 B2 6_1B3 3 B2 1/B2 B1/_/B_B3/ 2 1/2B 1 /B B2_1/
2 3 B5_1/4 6 B3 1B/_/2 /1_2 6 B1\n3 3 B10_6 B3 3 /2B_1_6 B1
4 2 B11_2B 1B_B2 B1_B 3 /1B/_/B_B2 B B_B1\n6 1B/11_1/3  B/_/2 3  B/_/"
IO.puts ASCII3D.decode(data)
Output:
 ____________    __
/\  _________\  /\ \    __                  __
\ \ \________/  \ \ \  /\_\    __      __  /\_\      ____
 \ \ \_______    \ \ \ \/_/_  /\_\__  /\_\ \/_/_    / ___\
  \ \  ______\    \ \ \  /\ \ \/_/\_\/ / /   /\ \  /\ \__/
   \ \ \_____/     \ \ \ \ \ \   \/_/ / /_   \ \ \ \ \ \
    \ \ \__________ \ \ \ \ \ \    / / /\_\__ \ \ \ \ \ \
     \ \___________\ \ \_\ \ \_\  / / /\/_/\_\ \ \_\ \ \_\
      \/___________/  \/_/  \/_/  \/_/    \/_/  \/_/  \/_/

Erlang

%% Implemented by Arjun Sunel
-module(three_d).
-export([main/0]).

main() ->
	io:format(" _____     _                   \n|  ___|   | |                  \n| |__ _ __| | __ _ _ __   __ _ \n|  __| '__| |/ _` | '_ \\ / _` |\n| |__| |  | | (_| | | | | (_| |\n|____/_|  |_|\\__,_|_| |_|\\__, |\n                          __/ |\n                         |___/\n").
Output:
 _____     _                   
|  ___|   | |                  
| |__ _ __| | __ _ _ __   __ _ 
|  __| '__| |/ _` | '_ \ / _` |
| |__| |  | | (_| | | | | (_| |
|____/_|  |_|\__,_|_| |_|\__, |
                          __/ |
                         |___/


3D ASCII:

Translation of: Elixir
-module(ascii3d).                                                            
-export([decode/1]).                                             

decode(Str) ->
    Splited = re:split(Str, "(\\d+)(\\D+)", [{return,list},group,trim]),
    Fun = fun([_,N,S]) -> {Num,_} = string:to_integer(N), lists:duplicate(Num, S) end,
    Joined = string:join(lists:flatmap(Fun, Splited), ""),
    Lines = binary:replace(binary:list_to_bin(Joined), <<"B">>, <<"\\">>, [global]),
    io:format("~s~n", [Lines]).
Output:
1> c("ascii3d.erl").                                                                
{ok,ascii3d}                                                                          
2> Str = "1 11_10 2_1\n1/B2 8_1B8 1/B B\n2B 1B7_1/7 3 B1\n3 B7_6 3_3B 3 6_2 2_2 4_4 6_1\n2 2B 1 6_1B4 1/ 3_3B 1 / 4_1 B/B B/ 2_1 B2 1/ 4_1 B\n2 3 B5_1/3 1/B B2_1/B2 B1/B B2_1/3B 1 /_2/B B2_1/B B\n3 3 B8_3B 1 5 B1_B/ 8 B1_B/  B\n4 2 B10_1B B_B3 2B B_3_1/2B_B 2B B_3_1/B B\n6 1B/10_1/B/_/4 1B/_/B/3_2/B/_1/2 1B/_/B/3_1/2B 1B\n55 3_1B/2 1)\n54 1/B5_1/\n54 1B/4_1/\n".
"1 11_10 2_1\n1/B2 8_1B8 1/B B\n2B 1B7_1/7 3 B1\n3 B7_6 3_3B 3 6_2 2_2 4_4 6_1\n2 2B 1 6_1B4 1/ 3_3B 1 / 4_1 B/B B/ 2_1 B2 1/ 4_1 B\n2 3 B5_1/3 1/B B2_1/B2 B1/B B2_1/3B 1 /_2/B B2_1/B B\n3 3 B8_3B 1 5 B1_B/ 8 B1_B/  B\n4 2 B10_1B B_B3 2B B_3_1/2B_B 2B B_3_1/B B\n6 1B/10_1/B/_/4 1B/_/B/3_2/B/_1/2 1B/_/B/3_1/2B 1B\n55 3_1B/2 1)\n54 1/B5_1/\n54 1B/4_1/\n"
3> ascii3d:decode(Str).                                                             
 ___________          __                                                         
/\  ________\        /\ \                                          
\ \ \_______/        \ \ \
 \ \ \_______      ___\ \ \    ______  __  ____    ______
  \ \  ______\    / ___\ \ \  / ____ \/\ \/ __ \  / ____ \
   \ \ \_____/   /\ \__/\ \ \/\ \__/\ \ \  /_/\ \/\ \__/\ \
    \ \ \________\ \ \   \ \ \ \ \_\/  \ \ \ \ \ \ \ \_\/  \
     \ \__________\ \_\   \ \_\ \____/\_\ \_\ \ \_\ \____/\ \
      \/__________/\/_/    \/_/\/___/\/_/\/_/  \/_/\/___/\ \ \
                                                       ___\/  )
                                                      /\_____/
                                                      \/____/

ok

ERRE

PROGRAM 3D_NAME

DIM TBL$[17,1]

BEGIN

FOR I=0 TO 17 DO
   READ(TBL$[I,0],TBL$[I,1])
END FOR

PRINT(CHR$(12);) ! CLS

FOR I=0 TO 17 DO
   PRINT(TBL$[I,1];TBL$[I,0];TBL$[I,0];TBL$[I,1])
END FOR

DATA("_________________     ","_____________    ")
DATA("|\               \    ","|\           \   ")
DATA("|\\_______________\   ","|\\___________\  ")
DATA("|\\|               \  ","|\\|           | ")
DATA("|\\|    ________    | ","|\\|   ________| ")
DATA("|\\|   |      |\|   | ","|\\|   |         ")
DATA("|\\|   |______|\|   | ","|\\|   |____     ")
DATA("|\\|   |       \|   | ","|\\|   |    \    ")
DATA("|\\|   |________|   | ","|\\|   |_____\   ")
DATA("|\\|                | ","|\\|         |   ")
DATA("|\\|    ___    ____/  ","|\\|    _____|   ")
DATA("|\\|   | \\\   \      ","|\\|   |         ")
DATA("|\\|   |  \\\   \     ","|\\|   |         ")
DATA("|\\|   |   \\\   \    ","|\\|   |______   ")
DATA("|\\|   |    \\\   \   ","|\\|   |      \  ")
DATA("|\\|   |     \\\   \  ","|\\|   |_______\ ")
DATA(" \\|   |      \\\   \ "," \\|           | ")
DATA("  \|___|       \\\___\","  \|___________| ")

END PROGRAM
Output:
_____________    _________________     _________________     _____________
|\           \   |\               \    |\               \    |\           \
|\\___________\  |\\_______________\   |\\_______________\   |\\___________\
|\\|           | |\\|               \  |\\|               \  |\\|           |
|\\|   ________| |\\|    ________    | |\\|    ________    | |\\|   ________|
|\\|   |         |\\|   |      |\|   | |\\|   |      |\|   | |\\|   |
|\\|   |____     |\\|   |______|\|   | |\\|   |______|\|   | |\\|   |____
|\\|   |    \    |\\|   |       \|   | |\\|   |       \|   | |\\|   |    \
|\\|   |_____\   |\\|   |________|   | |\\|   |________|   | |\\|   |_____\
|\\|         |   |\\|                | |\\|                | |\\|         |
|\\|    _____|   |\\|    ___    ____/  |\\|    ___    ____/  |\\|    _____|
|\\|   |         |\\|   | \\\   \      |\\|   | \\\   \      |\\|   |
|\\|   |         |\\|   |  \\\   \     |\\|   |  \\\   \     |\\|   |
|\\|   |______   |\\|   |   \\\   \    |\\|   |   \\\   \    |\\|   |______
|\\|   |      \  |\\|   |    \\\   \   |\\|   |    \\\   \   |\\|   |      \
|\\|   |_______\ |\\|   |     \\\   \  |\\|   |     \\\   \  |\\|   |_______\
 \\|           |  \\|   |      \\\   \  \\|   |      \\\   \  \\|           |
  \|___________|   \|___|       \\\___\  \|___|       \\\___\  \|___________|

F#

let make2Darray (picture : string list) =
    let maxY = picture.Length
    let maxX = picture |> List.maxBy String.length |> String.length
    let arr =
        (fun y x ->
            if picture.[y].Length <= x then ' '
            else picture.[y].[x])
        |> Array2D.init maxY maxX
    (arr, maxY, maxX)

let (cube, cy, cx) =
    [
        @"///\";
        @"\\\/";
    ]
    |> make2Darray


let (p2, my, mx) =
    [
        "*****";
        "*         *    * ";
        "*         *    * ";
        "*       **********";
        "****      *    * ";
        "*         *    * ";
        "*       **********";
        "*         *    * ";
        "*         *    * ";
    ]
    |> make2Darray

let a2 = Array2D.create (cy/2 * (my+1)) (cx/2 * mx + my) ' '

let imax = my * (cy/2)
for y in 0 .. Array2D.length1 p2 - 1 do
    for x in 0 .. Array2D.length2 p2 - 1 do
        let indent = Math.Max(imax - y, 0)
        if p2.[y, x] = '*' then Array2D.blit cube 0 0 a2 y (indent+x) cy cx

Array2D.iteri (fun y x c ->
    if x = 0 then printfn ""
    printf "%c" c) a2
Output:
         ///////\
        ///\\\\\/ ///\ ///\
       ///\/     ///\////\/
      ///\/   ////////////\
     //////\  \///\\///\\\/
    ///\\\\/  ///\////\/
   ///\/   ////////////\
  ///\/    \///\\///\\\/
 ///\/     ///\////\/
 \\\/      \\\/ \\\/

Forth

Text strings

\ Rossetta Code Write language name in 3D ASCII
\ Simple Method

: l1 ." /\\\\\\\\\\\\\  /\\\\         /\\\\\\\    /\\\\\\\\\\\\\  /\\\      /\\\"  CR ;
: l2 ." \/\\\///////// /\\\//\\\     /\\\/////\\\ \//////\\\////  \/\\\     \/\\\"  CR ;
: l3 ."  \/\\\        /\\\/ \///\\\  \/\\\   \/\\\      \/\\\      \/\\\     \/\\\"  CR ;
: l4 ."   \/\\\\\\\\\ /\\\     \//\\\ \/\\\\\\\\\/       \/\\\      \/\\\\\\\\\\\\\"  CR ;
: l5 ."    \/\\\///// \/\\\      \/\\\ \/\\\////\\\       \/\\\      \/\\\///////\\\"  CR ;
: l6 ."     \/\\\      \//\\\     /\\\  \/\\\  \//\\\      \/\\\      \/\\\     \/\\\"  CR ;
: l7 ."      \/\\\       \///\\\ /\\\    \/\\\   \//\\\     \/\\\      \/\\\     \/\\\"  CR ;
: l8 ."       \/\\\         \///\\\\/     \/\\\    \//\\\    \/\\\      \/\\\     \/\\\"  CR ;
: l9 ."        \///            \////       \///      \///     \///       \///      \///"  CR ;

: "FORTH"  cr L1 L2 L3 L4 L5 L6 L7 L8 l9 ;

( test at the console )
page "forth"
Output:

/\\\\\\\\\\\\\  /\\\\         /\\\\\\\    /\\\\\\\\\\\\\  /\\\      /\\\
\/\\\///////// /\\\//\\\     /\\\/////\\\ \//////\\\////  \/\\\     \/\\\
 \/\\\        /\\\/ \///\\\  \/\\\   \/\\\      \/\\\      \/\\\     \/\\\
  \/\\\\\\\\\ /\\\     \//\\\ \/\\\\\\\\\/       \/\\\      \/\\\\\\\\\\\\\
   \/\\\///// \/\\\      \/\\\ \/\\\////\\\       \/\\\      \/\\\///////\\\
    \/\\\      \//\\\     /\\\  \/\\\  \//\\\      \/\\\      \/\\\     \/\\\
     \/\\\       \///\\\ /\\\    \/\\\   \//\\\     \/\\\      \/\\\     \/\\\
      \/\\\         \///\\\\/     \/\\\    \//\\\    \/\\\      \/\\\     \/\\\
       \///            \////       \///      \///     \///       \///      \///
 ok

Bit Matrix Method

\ Original code:  "Short phrases with BIG Characters by Wil Baden  2003-02-23
\ Modified BFox  for simple 3D presentation 2015-07-14

\ Forth is a very low level language but by using primitive operations
\ we create new words in the language to solve the problem.

\ This solution coverts an acsii string to big text characters

HEX
: toUpper ( char -- char ) 05F and ;


: w,  ( n -- )  CSWAP , ;                      \ compile 'n', a 16 bit integer, into memory in the correct order


CREATE Banner-Matrix
    0000 w, 0000 w, 0000 w, 0000 w, 2020 w, 2020 w, 2000 w, 2000 w,
    5050 w, 5000 w, 0000 w, 0000 w, 5050 w, F850 w, F850 w, 5000 w,
    2078 w, A070 w, 28F0 w, 2000 w, C0C8 w, 1020 w, 4098 w, 1800 w,
    40A0 w, A040 w, A890 w, 6800 w, 3030 w, 1020 w, 0000 w, 0000 w,
    2040 w, 8080 w, 8040 w, 2000 w, 2010 w, 0808 w, 0810 w, 2000 w,
    20A8 w, 7020 w, 70A8 w, 2000 w, 0020 w, 2070 w, 2020 w, 0000 w,
    0000 w, 0030 w, 3010 w, 2000 w, 0000 w, 0070 w, 0000 w, 0000 w,
    0000 w, 0000 w, 0030 w, 3000 w, 0008 w, 1020 w, 4080 w, 0000 w,

    7088 w, 98A8 w, C888 w, 7000 w, 2060 w, 2020 w, 2020 w, 7000 w,
    7088 w, 0830 w, 4080 w, F800 w, F810 w, 2030 w, 0888 w, 7000 w,
    1030 w, 5090 w, F810 w, 1000 w, F880 w, F008 w, 0888 w, 7000 w,
    3840 w, 80F0 w, 8888 w, 7000 w, F808 w, 1020 w, 4040 w, 4000 ,
    7088 w, 8870 w, 8888 w, 7000 w, 7088 w, 8878 w, 0810 w, E000 w,
    0060 w, 6000 w, 6060 w, 0000 w, 0060 w, 6000 w, 6060 w, 4000 w,
    1020 w, 4080 w, 4020 w, 1000 w, 0000 w, F800 w, F800 w, 0000 w,
    4020 w, 1008 w, 1020 w, 4000 w, 7088 w, 1020 w, 2000 w, 2000 w,

    7088 w, A8B8 w, B080 w, 7800 w, 2050 w, 8888 w, F888 w, 8800 w,
    F088 w, 88F0 w, 8888 w, F000 w, 7088 w, 8080 w, 8088 w, 7000 w,
    F048 w, 4848 w, 4848 w, F000 w, F880 w, 80F0 w, 8080 w, F800 w,
    F880 w, 80F0 w, 8080 w, 8000 w, 7880 w, 8080 w, 9888 w, 7800 w,
    8888 w, 88F8 w, 8888 w, 8800 w, 7020 w, 2020 w, 2020 w, 7000 w,
    0808 w, 0808 w, 0888 w, 7800 w, 8890 w, A0C0 w, A090 w, 8800 w,
    8080 w, 8080 w, 8080 w, F800 w, 88D8 w, A8A8 w, 8888 w, 8800 w,
    8888 w, C8A8 w, 9888 w, 8800 w, 7088 w, 8888 w, 8888 w, 7000 w,

    F088 w, 88F0 w, 8080 w, 8000 w, 7088 w, 8888 w, A890 w, 6800 w,
    F088 w, 88F0 w, A090 w, 8800 w, 7088 w, 8070 w, 0888 w, 7000 w,
    F820 w, 2020 w, 2020 w, 2000 w, 8888 w, 8888 w, 8888 w, 7000 w,
    8888 w, 8888 w, 8850 w, 2000 w, 8888 w, 88A8 w, A8D8 w, 8800 w,
    8888 w, 5020 w, 5088 w, 8800 w, 8888 w, 5020 w, 2020 w, 2000 w,
    F808 w, 1020 w, 4080 w, F800 w, 7840 w, 4040 w, 4040 w, 7800 w,
    0080 w, 4020 w, 1008 w, 0000 w, F010 w, 1010 w, 1010 w, F000 w,
    0000 w, 2050 w, 8800 w, 0000 w, 0000 w, 0000 w, 0000 w, 00F8 w,


: >col      ( char -- ndx )                      \ convert ascii char into column index in the matrix
             toupper BL -  0 MAX ;               \ Space char (BL) = 0.  Index is clipped to 0 as minimum value


: ]banner-matrix  (  row ascii -- addr )         \ convert Banner-matrix memory to a 2 dimensional matrix
               >col   8 * Banner-matrix +  +  ;


: PLACE        ( str len addr -- )               \ store a string with length at addr
               2DUP 2>R  1+  SWAP  MOVE  2R> C! ;

synonym len  c@                                  \ fetch the 1st char of a counted string to return the length

: BIT?          ( byte bit# -- -1 | 0)           \ given a byte and bit# on stack, return true or false flag
                 1 swap lshift AND ;

DECIMAL

variable bannerstr  5 allot                      \ memory for the character string

\ Font selection characters stored as counted strings
: STARFONT    S" *"  bannerstr PLACE ;
: HASHFONT    S" ##" bannerstr PLACE ;
: 3DFONT      S" _/" bannerstr PLACE ;


: .BIGCHAR ( matrix-byte -- )
         2 7                                     \ we use bits 7 to 2
         DO
             dup I bit?                          \ check bit I in the matrix-byte on stack
             IF   bannerstr count TYPE           \ if BIT=TRUE
             ELSE bannerstr len   SPACES         \ if BIT=false
             THEN
         -1 +LOOP                                \ loop backwards
         DROP ;                                  \ drop the matrix-byte                        

: BANNER ( str len -- )
        8 0
        DO  CR                                   \ str len
            2dup
            BOUNDS                               \ calc. begin & end addresses of string
            DO
               J I C@ ]Banner-Matrix C@ .BIGCHAR
            LOOP                                 \ str len
        LOOP
        2DROP ;                                  \ drop str & len

\ test the solution in the Forth console
Output:
3DFONT  s" FORTH" banner
_/_/_/_/_/    _/_/_/    _/_/_/_/    _/_/_/_/_/  _/      _/
_/          _/      _/  _/      _/      _/      _/      _/
_/          _/      _/  _/      _/      _/      _/      _/
_/_/_/_/    _/      _/  _/_/_/_/        _/      _/_/_/_/_/
_/          _/      _/  _/  _/          _/      _/      _/
_/          _/      _/  _/    _/        _/      _/      _/
_/            _/_/_/    _/      _/      _/      _/      _/
                                                             ok
hashfont  ok
s" FORTH" BANNER
#####  ###  ####  ##### #   #
#     #   # #   #   #   #   #
#     #   # #   #   #   #   #
####  #   # ####    #   #####
#     #   # # #     #   #   #
#     #   # #  #    #   #   #
#      ###  #   #   #   #   #
                               ok


FutureBasic

_window = 1
begin enum 1
  _asciiField
end enum

void local fn BuildWindow
  CGRect r = fn CGRectMake( 0, 0, 610, 140 )
  window _window, @"Rosetta Code — FutureBasic in 3D ASCII", r, NSWindowStyleMaskTitled + NSWindowStyleMaskClosable
  WindowSetBackgroundColor( _window, fn ColorBlack )
  
  CFStringRef asciiFB = @" ¬
  /$$$$$$$$            / $$                                   /$$$$$$$                      /$$        \n¬
  | $$_____/            | $$                                  | $$__  $$                    |__/          \n¬
  | $$       /$$   /$$ /$$$$$$   /$$   /$$  /$$$$$$   /$$$$$$ | $$  \\ $$  /$$$$$$   /$$$$$$$ /$$  /$$$$$$$\n¬
  | $$$$$   | $$  | $$|_  $$_/  | $$  | $$ /$$__  $$ /$$__  $$| $$$$$$$  |____  $$ /$$_____/| $$ /$$_____/\n¬
  | $$__/   | $$  | $$  | $$    | $$  | $$| $$  \\__/| $$$$$$$$| $$__  $$  /$$$$$$$|  $$$$$$ | $$| $$      \n¬
  | $$      | $$  | $$  | $$ /$$| $$  | $$| $$      | $$_____/| $$  \\ $$ /$$__  $$ \\____  $$| $$| $$      \n¬
  | $$      |  $$$$$$/  |  $$$$/|  $$$$$$/| $$      |  $$$$$$$| $$$$$$$/|  $$$$$$$ /$$$$$$$/| $$|  $$$$$$$\n¬
  |__/      \\______/    \\___/   \\______/ |__/       \\_______/|_______/  \\_______/|_______/ |__/ \\_______/\n"
  
  r = fn CGRectMake( 22, 20, 582, 100 )
  textfield _asciiField, YES, asciiFB, r, _window
  TextFieldSetTextColor(       _asciiField, fn ColorYellow )
  TextFieldSetBordered(        _asciiField, NO             )
  TextFieldSetBackgroundColor( _asciiField, fn ColorBlack  )
  ControlSetFontWithName(      _asciiField, @"Menlo", 9.0  )
end fn

void local fn DoDialog( ev as long, tag as long, wnd as long )
  select ( ev )
    case _windowWillClose : end
  end select
end fn

on dialog fn DoDialog

fn BuildWindow

HandleEvents
Output:


Go

Go does have a "Go" logo, although it is rarely used. A graphic is at http://golang.org/doc/gopher/bumper.png and the logo is the word Go with the two little lines to suggest movement. It's not 3D, so for inspiration I googled 3D ASCII fonts or something similar and found Patrick Gillespie's site at patorjk.com/software/taag/ with lots of ASCII fonts. The first one I liked was "Block" for its simple 3D illusion of drawing only the shadow, then I found "Lean." It's the same 3D effect as Block only slanted, reminiscent of the slanted Go logo.

For the interest component of the task, I thought about rendering the result from an input string and realized that it wasn't completely trivial as the glyphs of the Lean font overlap with the standard letter spacing. Rendering different fonts would add interest because now there would be a point in developing a common font representation and rendering function. Block and Lean would have sufficed, but I looked further and found the Keyboard and Small Keyboard fonts. These I found somewhat amusing, for the final component of the task. 

package main

import (
    "fmt"
    "strings"
)

var lean = font{
    height:  5,
    slant:   1,
    spacing: 2,
    m: map[rune][]string{
        'G': []string{
            `  _/_/_/`,
            `_/      `,
            `_/  _/_/`,
            `_/    _/`,
            `  _/_/_/`,
        },
        'o': []string{
            `        `,
            `  _/_/  `,
            `_/    _/`,
            `_/    _/`,
            `  _/_/  `,
        },
    }}

var smallKeyboard = font{
    height:  4,
    slant:   0,
    spacing: -1,
    m: map[rune][]string{
        'G': []string{
            ` ____ `,
            `||G ||`,
            `||__||`,
            `|/__\|`,
        },
        'o': []string{
            ` ____ `,
            `||o ||`,
            `||__||`,
            `|/__\|`,
        },
    }}

type font struct {
    height  int
    slant   int
    spacing int
    m       map[rune][]string
}

func render(s string, f font) string {
    rows := make([]string, f.height)
    if f.slant != 0 {
        start := 0
        if f.slant > 0 {
            start = f.height
        }
        for i := range rows {
            rows[i] = strings.Repeat(" ", (start-i)*f.slant)
        }
    }
    if f.spacing >= 0 {
        spacing := strings.Repeat(" ", f.spacing)
        for j, c := range s {
            for i, r := range f.m[c] {
                if j > 0 {
                    r = spacing + r
                }
                rows[i] += r
            }
        }
    } else {
        overlap := -f.spacing
        for j, c := range s {
            for i, r := range f.m[c] {
                if j > 0 {
                    r = r[overlap:]
                }
                rows[i] += r
            }
        }
    }
    return strings.Join(rows, "\n")
}

func main() {
    fmt.Println(render("Go", lean))
    fmt.Println(render("Go", smallKeyboard))
}
Output:
       _/_/_/          
    _/          _/_/  
   _/  _/_/  _/    _/
  _/    _/  _/    _/
   _/_/_/    _/_/  
 ____ ____ 
||G |||o ||
||__|||__||
|/__\|/__\|

Groovy

A simple way to display ASCII art 

println """\
  _|_|_|
_|        _|  _|_|    _|_|      _|_|    _|      _|  _|    _|
_|  _|_|  _|_|      _|    _|  _|    _|  _|      _|  _|    _|
_|    _|  _|        _|    _|  _|    _|    _|  _|    _|    _|
  _|_|_|  _|          _|_|      _|_|        _|        _|_|_|
                                                          _|
                                                      _|_|"""

A more complicated example: 

String.metaClass.getAsAsciiArt = {
    def request = "http://www.network-science.de/ascii/ascii.php?TEXT=${delegate}&x=23&y=10&FONT=block&RICH=no&FORM=left&STRE=no&WIDT=80"
    def html = new URL(request).text
    (html =~ '<TD><PRE>([^<]+)</PRE>')[-1][1]
}

println "Groovy".asAsciiArt
Output:
  _|_|_|
_|        _|  _|_|    _|_|      _|_|    _|      _|  _|    _|
_|  _|_|  _|_|      _|    _|  _|    _|  _|      _|  _|    _|
_|    _|  _|        _|    _|  _|    _|    _|  _|    _|    _|
  _|_|_|  _|          _|_|      _|_|        _|        _|_|_|
                                                          _|
                                                      _|_|

Haskell

A simple printing of the ASCII art 

module Main where
{-
 __  __                    __              ___    ___
/\ \/\ \                  /\ \            /\_ \  /\_ \
\ \ \_\ \     __      ____\ \ \/'\      __\//\ \ \//\ \
 \ \  _  \  /'__`\   /',__\\ \ , <    /'__`\\ \ \  \ \ \
  \ \ \ \ \/\ \L\.\_/\__, `\\ \ \\`\ /\  __/ \_\ \_ \_\ \_
   \ \_\ \_\ \__/.\_\/\____/ \ \_\ \_\ \____\/\____\/\____\
    \/_/\/_/\/__/\/_/\/___/   \/_/\/_/\/____/\/____/\/____/
-}

ascii3d :: String
ascii3d = " __  __                    __              ___    ___      \n" ++
          "/\\ \\/\\ \\                  /\\ \\            /\\_ \\  /\\_ \\     \n" ++
          "\\ \\ \\_\\ \\     __      ____\\ \\ \\/'\\      __\\//\\ \\ \\//\\ \\    \n" ++
          " \\ \\  _  \\  /'__`\\   /',__\\\\ \\ , <    /'__`\\\\ \\ \\  \\ \\ \\   \n" ++
          "  \\ \\ \\ \\ \\/\\ \\L\\.\\_/\\__, `\\\\ \\ \\\\`\\ /\\  __/ \\_\\ \\_ \\_\\ \\_ \n" ++
          "   \\ \\_\\ \\_\\ \\__/.\\_\\/\\____/ \\ \\_\\ \\_\\ \\____\\/\\____\\/\\____\\\n" ++
          "    \\/_/\\/_/\\/__/\\/_/\\/___/   \\/_/\\/_/\\/____/\\/____/\\/____/"

main = putStrLn ascii3d
Output:
 __  __                    __              ___    ___
/\ \/\ \                  /\ \            /\_ \  /\_ \
\ \ \_\ \     __      ____\ \ \/'\      __\//\ \ \//\ \
 \ \  _  \  /'__`\   /',__\\ \ , <    /'__`\\ \ \  \ \ \
  \ \ \ \ \/\ \L\.\_/\__, `\\ \ \\`\ /\  __/ \_\ \_ \_\ \_
   \ \_\ \_\ \__/.\_\/\____/ \ \_\ \_\ \____\/\____\/\____\
    \/_/\/_/\/__/\/_/\/___/   \/_/\/_/\/____/\/____/\/____/

Icon and Unicon

The following fits under the fuzzy definition of 3D ASCII and pays homage to one of the Icon Newsletter logos. 

procedure main(arglist)
write(ExpandText(
   if !arglist == "icon" then 
      "14/\\\n14\\/\n12/\\\n11/1/\n10/1/1/\\\n10\\/1/2\\\n12/1/\\1\\\n_
      12\\1\\1\\/\n10/\\1\\1\\2/\\\n9/2\\1\\/1/2\\\n_
      8/1/\\1\\2/1/\\1\\2/\\\n8\\1\\/1/2\\1\\/1/2\\1\\\n_
      6/\\1\\2/4\\2/1/\\1\\1\\\n5/1/2\\/6\\/1/2\\1\\/\n_
      /\\2/1/1/\\10/1/\\1\\2/\\\n\\/2\\1\\/1/10\\/1/1/2\\/\n_
      2/\\1\\2/1/\\6/\\2/1/\n2\\1\\1\\/1/2\\4/2\\1\\/\n_
      3\\1\\2/1/\\1\\2/1/\\1\\\n4\\/2\\1\\/1/2\\1\\/1/\n_
      9\\2/1/\\1\\2/\n10\\/2\\1\\1\\/\n12/\\1\\1\\\n12\\1\\/1/\n_
      13\\2/1/\\\n14\\/1/1/\n16/1/\n16\\/\n14/\\\n14\\/\n"
   else 
      "13/\\\n12/1/\n11/1/1/\\\n11\\1\\/1/\n12\\2/1/\\\n13\\/1/2\\\n_
     15/1/\\1\\2/\\\n15\\/1/1/2\\/\n17/1/1/\\18/\\\n17\\/1/1/17/2\\\n_
     19/1/1/\\14/1/\\1\\\n19\\/1/2\\13\\1\\1\\/\n21/1/\\1\\10/\\1\\1\\\n_
     21\\1\\1\\/10\\1\\1\\/\n19/\\1\\1\\2/\\6/\\1\\1\\\n_
     18/2\\1\\/1/2\\5\\1\\/1/\n17/1/\\1\\2/1/\\1\\2/\\1\\2/\n_
     17\\1\\/1/2\\1\\/1/2\\1\\1\\/\n15/\\1\\2/4\\2/1/\\1\\1\\\n_
     14/1/2\\/6\\/1/2\\1\\/\n9/\\2/1/1/\\10/1/\\1\\2/\\\n_
     9\\/2\\1\\/1/10\\/1/1/2\\/\n11/\\1\\2/1/\\6/\\2/1/\n_
     11\\1\\1\\/1/2\\4/2\\1\\/\n9/\\1\\1\\2/1/\\1\\2/1/\\1\\\n_
     8/2\\1\\/2\\1\\/1/2\\1\\/1/\n7/1/\\1\\5\\2/1/\\1\\2/\n_
     7\\1\\1\\/6\\/2\\1\\1\\/\n5/\\1\\1\\10/\\1\\1\\\n_
     5\\1\\1\\/10\\1\\/1/\n3/\\1\\1\\13\\2/1/\\\n3\\1\\/1/14\\/1/1/\n_
     4\\2/17/1/1/\\\n5\\/18\\/1/1/\n23/\\2/1/1/\\\n23\\/2\\1\\/1/\n_
     28\\2/1/\\\n29\\/1/2\\\n31/1/\\1\\\n31\\/1/1/\n33/1/\n33\\/\n"
     ))
end

procedure ExpandText(s)
s ? until pos(0) do 
      writes(repl(" ",tab(many(&digits)))|tab(upto(&digits)|0))
end
Output:

with "icon" as the argument 

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

J

   require 'vrml.ijs'                       NB.  Due to Andrew Nikitin 
   view 5#.^:_1]21-~a.i.'j*ez`C3\toy.G)'  NB.  Due to Oleg Kobchenko 
       ________________________    
      |\     \     \     \     \   
      | \_____\_____\_____\_____\  
      | |     |     |     |\     \ 
      |\|     |     |     | \_____\
      | \_____|_____|_____| |     |
      | |     |   | |     |\|     |
       \|     |   |\|     | \_____|
        \_____|   | \_____|        
                  | |     |        
                  |\|     |        
                  | \_____|        
 ______           | |     |        
|\     \          |\|     |        
| \_____\_________|_\_____|        
| |\     \     \     \    |        
 \| \_____\_____\_____\   |        
  | |     |     |     |___|        
   \|     |     |     |            
    \_____|_____|_____|

For the VRML script, see Andrew Nikitin's J page (search for VRML) and for the origin of the 3D J banner, see Oleg Kobchenko's post to the J Forums.

Here's a slimmer version: 

   view 8 8 8#:'"#$%&,4<DHLPTYZ[\'-&(a.&i.)' '
                     
                     
                     
                     
     ______          
    |\     \         
    | \_____\        
    | |\     \       
     \| \_____\      
      | |\     \     
       \| \_____\    
        | |\     \   
        |\| \_____\  
        | | |\     \ 
        | |\| \_____\
 ______ |\| | |     |
|\     \| \__\|     |
| \_____| |   \_____|
| |     |\|     |    
|\|     | \_____|    
| \_____| |     |    
| |     |\|     |    
 \|     | \_____|    
  \_____| |     |    
  |\    |\|     |    
  | \___| \_____|    
  | |\  | |     |    
   \| \_|\|     |    
    | |\| \_____|    
     \| | |     |    
      | |\|     |    
       \| \_____|    
        | |     |    
         \|     |    
          \_____|

Explanation: the argument says where to place the solid "blocks". Each block is described by three integers, describing position along the x, y and z axis. In other words, 1 0 0 is one position to the right of 0 0 0, while 0 1 0 is one place down and 0 0 1 is one place towards the observer. (Thus the space at the top of the "slimmer" version could have been eliminated by subtracting 2 from the middle column of integers being passed to 'view'.)

It's convenient to encode these three element values as ascii characters. The original used base 5 (after subtracting 21), the alternate version used octal (after subtracting 32).

Note that the order the block positions are described in is irrelevant (the characters indicating position could be shuffled with no change in the rendered result).

Java

This was written ages ago as an exercise in obfuscation, and improved here with upper case letters. The font is "lean" from figlet.

It's not really that obfuscated. The characters in z are used to draw the letters. The array f contains one element per letter of the alphabet. Each array element is another array of 7 longs because each output letter is made of 7 lines of text. Each long value represents a sequence of 2-bit integers that are extracted by bit-twiddling and used to find the right character in z. 

public class F5{
    char[]z={' ',' ','_','/',};
    long[][]f={
        {87381,87381,87381,87381,87381,87381,87381,},
        {349525,375733,742837,742837,375733,349525,349525,},
        {742741,768853,742837,742837,768853,349525,349525,},
        {349525,375733,742741,742741,375733,349525,349525,},
        {349621,375733,742837,742837,375733,349525,349525,},
        {349525,375637,768949,742741,375733,349525,349525,},
        {351157,374101,768949,374101,374101,349525,349525,},
        {349525,375733,742837,742837,375733,349621,351157,},
        {742741,768853,742837,742837,742837,349525,349525,},
        {181,85,181,181,181,85,85,},
        {1461,1365,1461,1461,1461,1461,2901,},
        {742741,744277,767317,744277,742837,349525,349525,},
        {181,181,181,181,181,85,85,},
        {1431655765,3149249365L,3042661813L,3042661813L,3042661813L,1431655765,1431655765,},
        {349525,768853,742837,742837,742837,349525,349525,},
        {349525,375637,742837,742837,375637,349525,349525,},
        {349525,768853,742837,742837,768853,742741,742741,},
        {349525,375733,742837,742837,375733,349621,349621,},
        {349525,744373,767317,742741,742741,349525,349525,},
        {349525,375733,767317,351157,768853,349525,349525,},
        {374101,768949,374101,374101,351157,349525,349525,},
        {349525,742837,742837,742837,375733,349525,349525,},
        {5592405,11883957,11883957,5987157,5616981,5592405,5592405,},
        {366503875925L,778827027893L,778827027893L,392374737749L,368114513237L,366503875925L,366503875925L,},
        {349525,742837,375637,742837,742837,349525,349525,},
        {349525,742837,742837,742837,375733,349621,375637,},
        {349525,768949,351061,374101,768949,349525,349525,},
        {375637,742837,768949,742837,742837,349525,349525,},
        {768853,742837,768853,742837,768853,349525,349525,},
        {375733,742741,742741,742741,375733,349525,349525,},
        {192213,185709,185709,185709,192213,87381,87381,},
        {1817525,1791317,1817429,1791317,1817525,1398101,1398101,},
        {768949,742741,768853,742741,742741,349525,349525,},
        {375733,742741,744373,742837,375733,349525,349525,},
        {742837,742837,768949,742837,742837,349525,349525,},
        {48053,23381,23381,23381,48053,21845,21845,},
        {349621,349621,349621,742837,375637,349525,349525,},
        {742837,744277,767317,744277,742837,349525,349525,},
        {742741,742741,742741,742741,768949,349525,349525,},
        {11883957,12278709,11908533,11883957,11883957,5592405,5592405,},
        {11883957,12277173,11908533,11885493,11883957,5592405,5592405,},
        {375637,742837,742837,742837,375637,349525,349525,},
        {768853,742837,768853,742741,742741,349525,349525,},
        {6010197,11885397,11909973,11885397,6010293,5592405,5592405,},
        {768853,742837,768853,742837,742837,349525,349525,},
        {375733,742741,375637,349621,768853,349525,349525,},
        {12303285,5616981,5616981,5616981,5616981,5592405,5592405,},
        {742837,742837,742837,742837,375637,349525,349525,},
        {11883957,11883957,11883957,5987157,5616981,5592405,5592405,},
        {3042268597L,3042268597L,3042661813L,1532713813,1437971797,1431655765,1431655765,},
        {11883957,5987157,5616981,5987157,11883957,5592405,5592405,},
        {11883957,5987157,5616981,5616981,5616981,5592405,5592405,},
        {12303285,5593941,5616981,5985621,12303285,5592405,5592405,},};
    public static void main(String[]a){
        new F5(a.length>0?a[0]:"Java");}
    private F5(String s){
        StringBuilder[]o=new StringBuilder[7];
        for(int i=0;i<7;i++)o[i]=new StringBuilder();
        for(int i=0,l=s.length();i<l;i++){
            int c=s.charAt(i);
            if(65<=c&&c<=90)c-=39;
            else if(97<=c&&c<=122)c-=97;
            else c=-1;
            long[]d=f[++c];
            for(int j=0;j<7;j++){
                StringBuilder b=new StringBuilder();
                long v=d[j];
                while(v>0){
                    b.append(z[(int)(v&3)]);
                    v>>=2;}
                o[j].append(b.reverse().toString());}}
        for(int i=0;i<7;i++){
            for(int j=0;j<7-i;j++)
                System.out.print(' ');
            System.out.println(o[i]);}}}
Output:

With no parameters 

             _/                                  
            _/    _/_/_/  _/      _/    _/_/_/  
           _/  _/    _/  _/      _/  _/    _/  
    _/    _/  _/    _/    _/  _/    _/    _/  
     _/_/      _/_/_/      _/        _/_/_/

Pass "Something Else" and the output is:

Output:
         _/_/_/                                        _/      _/        _/                                _/_/_/_/  _/                      
      _/          _/_/    _/_/_/  _/_/      _/_/    _/_/_/_/  _/_/_/        _/_/_/      _/_/_/            _/        _/    _/_/_/    _/_/    
       _/_/    _/    _/  _/    _/    _/  _/_/_/_/    _/      _/    _/  _/  _/    _/  _/    _/            _/_/_/    _/  _/_/      _/_/_/_/  
          _/  _/    _/  _/    _/    _/  _/          _/      _/    _/  _/  _/    _/  _/    _/            _/        _/      _/_/  _/        
   _/_/_/      _/_/    _/    _/    _/    _/_/_/      _/_/  _/    _/  _/  _/    _/    _/_/_/            _/_/_/_/  _/  _/_/_/      _/_/_/  
                                                                                        _/                                              
                                                                                     _/_/

jq

Works with: jq

Works with gojq, the Go implementation of jq

One small point of interest here is the use of string interpolation to simulate a "heredoc" string. 

def jq:
"\("
                     #
                #
               #     #   ###
              #      #  #   #
             #       #  #   #
        #   #    #   #   ####
           #      ###       #
                            #
")";                 

def banner3D:
  jq | split("\n") | map( gsub("#"; "╔╗") | gsub(" "; "  ") )
  | [[range(length;0;-1) | " " * .], . ] | transpose[] | join("") ;

banner3D
Output:
                                                   ╔╗
                                        ╔╗
                                     ╔╗          ╔╗      ╔╗╔╗╔╗
                                  ╔╗            ╔╗    ╔╗      ╔╗
                               ╔╗              ╔╗    ╔╗      ╔╗
                    ╔╗      ╔╗        ╔╗      ╔╗      ╔╗╔╗╔╗╔╗
                         ╔╗            ╔╗╔╗╔╗              ╔╗
                                                          ╔╗

Julia

Translation of: Awk
println(replace(raw"""
  xxxxx                 
     x            x         
     x            x   x       
     x   x  x   x             
     x   x  x   x   x    xxx
     x   x  x   x   x   x   x
 x  x   x  x   x   x   x   xx
  xx     xx    x   x    x x xx
 """, "x" => "_/"))
Output:


 _/_/_/_/_/
    _/            _/
    _/            _/   _/
    _/   _/  _/   _/
    _/   _/  _/   _/   _/    _/_/_/
    _/   _/  _/   _/   _/   _/   _/
_/  _/   _/  _/   _/   _/   _/   _/_/
 _/_/     _/_/    _/   _/    _/ _/ _/_/

Kotlin

Translation of: Java
// version 1.1

class Ascii3D(s: String) {
    val z = charArrayOf(' ', ' ', '_', '/')

    val f = arrayOf(
        longArrayOf(87381, 87381, 87381, 87381, 87381, 87381, 87381),
        longArrayOf(349525, 375733, 742837, 742837, 375733, 349525, 349525),
        longArrayOf(742741, 768853, 742837, 742837, 768853, 349525, 349525),
        longArrayOf(349525, 375733, 742741, 742741, 375733, 349525, 349525),
        longArrayOf(349621, 375733, 742837, 742837, 375733, 349525, 349525),
        longArrayOf(349525, 375637, 768949, 742741, 375733, 349525, 349525),
        longArrayOf(351157, 374101, 768949, 374101, 374101, 349525, 349525),
        longArrayOf(349525, 375733, 742837, 742837, 375733, 349621, 351157),
        longArrayOf(742741, 768853, 742837, 742837, 742837, 349525, 349525),
        longArrayOf(181, 85, 181, 181, 181, 85, 85),
        longArrayOf(1461, 1365, 1461, 1461, 1461, 1461, 2901),
        longArrayOf(742741, 744277, 767317, 744277, 742837, 349525, 349525),
        longArrayOf(181, 181, 181, 181, 181, 85, 85),
        longArrayOf(1431655765, 3149249365L, 3042661813L, 3042661813L, 3042661813L, 1431655765, 1431655765),
        longArrayOf(349525, 768853, 742837, 742837, 742837, 349525, 349525),
        longArrayOf(349525, 375637, 742837, 742837, 375637, 349525, 349525),
        longArrayOf(349525, 768853, 742837, 742837, 768853, 742741, 742741),
        longArrayOf(349525, 375733, 742837, 742837, 375733, 349621, 349621),
        longArrayOf(349525, 744373, 767317, 742741, 742741, 349525, 349525),
        longArrayOf(349525, 375733, 767317, 351157, 768853, 349525, 349525),
        longArrayOf(374101, 768949, 374101, 374101, 351157, 349525, 349525),
        longArrayOf(349525, 742837, 742837, 742837, 375733, 349525, 349525),
        longArrayOf(5592405, 11883957, 11883957, 5987157, 5616981, 5592405, 5592405),
        longArrayOf(366503875925L, 778827027893L, 778827027893L, 392374737749L, 368114513237L, 366503875925L, 366503875925L),
        longArrayOf(349525, 742837, 375637, 742837, 742837, 349525, 349525),
        longArrayOf(349525, 742837, 742837, 742837, 375733, 349621, 375637),
        longArrayOf(349525, 768949, 351061, 374101, 768949, 349525, 349525),
        longArrayOf(375637, 742837, 768949, 742837, 742837, 349525, 349525),
        longArrayOf(768853, 742837, 768853, 742837, 768853, 349525, 349525),
        longArrayOf(375733, 742741, 742741, 742741, 375733, 349525, 349525),
        longArrayOf(192213, 185709, 185709, 185709, 192213, 87381, 87381),
        longArrayOf(1817525, 1791317, 1817429, 1791317, 1817525, 1398101, 1398101),
        longArrayOf(768949, 742741, 768853, 742741, 742741, 349525, 349525),
        longArrayOf(375733, 742741, 744373, 742837, 375733, 349525, 349525),
        longArrayOf(742837, 742837, 768949, 742837, 742837, 349525, 349525),
        longArrayOf(48053, 23381, 23381, 23381, 48053, 21845, 21845),
        longArrayOf(349621, 349621, 349621, 742837, 375637, 349525, 349525),
        longArrayOf(742837, 744277, 767317, 744277, 742837, 349525, 349525),
        longArrayOf(742741, 742741, 742741, 742741, 768949, 349525, 349525),
        longArrayOf(11883957, 12278709, 11908533, 11883957, 11883957, 5592405, 5592405),
        longArrayOf(11883957, 12277173, 11908533, 11885493, 11883957, 5592405, 5592405),
        longArrayOf(375637, 742837, 742837, 742837, 375637, 349525, 349525),
        longArrayOf(768853, 742837, 768853, 742741, 742741, 349525, 349525),
        longArrayOf(6010197, 11885397, 11909973, 11885397, 6010293, 5592405, 5592405),
        longArrayOf(768853, 742837, 768853, 742837, 742837, 349525, 349525),
        longArrayOf(375733, 742741, 375637, 349621, 768853, 349525, 349525),
        longArrayOf(12303285, 5616981, 5616981, 5616981, 5616981, 5592405, 5592405),
        longArrayOf(742837, 742837, 742837, 742837, 375637, 349525, 349525),
        longArrayOf(11883957, 11883957, 11883957, 5987157, 5616981, 5592405, 5592405),
        longArrayOf(3042268597L, 3042268597L, 3042661813L, 1532713813, 1437971797, 1431655765, 1431655765),
        longArrayOf(11883957, 5987157, 5616981, 5987157, 11883957, 5592405, 5592405),
        longArrayOf(11883957, 5987157, 5616981, 5616981, 5616981, 5592405, 5592405),
        longArrayOf(12303285, 5593941, 5616981, 5985621, 12303285, 5592405, 5592405)
    )

    init {
        val o = Array(7) { StringBuilder() }
        for (i in 0 until s.length) {
            var c = s[i].toInt()
            if (c in 65..90) {
                c -= 39
            } else if (c in 97..122) {
                c -= 97
            } else {
                c = -1
            }
            val d = f[++c]
            for (j in 0 until 7) {
                val b = StringBuilder()
                var v = d[j]
                while (v > 0) {
                    b.append(z[(v and 3).toInt()])
                    v = v shr 2
                }
                o[j].append(b.reverse().toString())
            }
        }
        for (i in 0 until 7) {
            for (j in 0 until 7 - i) print(' ')
            println(o[i])
        }
    }
}

fun main(args: Array<String>) {
    Ascii3D("KOTLIN")
    Ascii3D("with thanks")
    Ascii3D("to the author")
    Ascii3D("of the")
    Ascii3D("Java entry")
}
Output:
       _/    _/    _/_/    _/_/_/_/_/  _/        _/_/_/  _/      _/
      _/  _/    _/    _/      _/      _/          _/    _/_/    _/
     _/_/      _/    _/      _/      _/          _/    _/  _/  _/
    _/  _/    _/    _/      _/      _/          _/    _/    _/_/
   _/    _/    _/_/        _/      _/_/_/_/  _/_/_/  _/      _/


                           _/    _/      _/                   _/      _/                            _/
      _/      _/      _/      _/_/_/_/  _/_/_/             _/_/_/_/  _/_/_/      _/_/_/  _/_/_/    _/  _/      _/_/_/
     _/      _/      _/  _/    _/      _/    _/             _/      _/    _/  _/    _/  _/    _/  _/_/      _/_/
      _/  _/  _/  _/    _/    _/      _/    _/             _/      _/    _/  _/    _/  _/    _/  _/  _/        _/_/
       _/      _/      _/      _/_/  _/    _/               _/_/  _/    _/    _/_/_/  _/    _/  _/    _/  _/_/_/


         _/                           _/      _/                                                 _/      _/
      _/_/_/_/    _/_/             _/_/_/_/  _/_/_/      _/_/               _/_/_/  _/    _/  _/_/_/_/  _/_/_/      _/_/    _/  _/_/
       _/      _/    _/             _/      _/    _/  _/_/_/_/           _/    _/  _/    _/    _/      _/    _/  _/    _/  _/_/
      _/      _/    _/             _/      _/    _/  _/                 _/    _/  _/    _/    _/      _/    _/  _/    _/  _/
       _/_/    _/_/                 _/_/  _/    _/    _/_/_/             _/_/_/    _/_/_/      _/_/  _/    _/    _/_/    _/


                     _/_/             _/      _/
        _/_/      _/               _/_/_/_/  _/_/_/      _/_/
     _/    _/  _/_/_/_/             _/      _/    _/  _/_/_/_/
    _/    _/    _/                 _/      _/    _/  _/
     _/_/      _/                   _/_/  _/    _/    _/_/_/


             _/                                                                 _/
            _/    _/_/_/  _/      _/    _/_/_/             _/_/    _/_/_/    _/_/_/_/  _/  _/_/  _/    _/
           _/  _/    _/  _/      _/  _/    _/           _/_/_/_/  _/    _/    _/      _/_/      _/    _/
    _/    _/  _/    _/    _/  _/    _/    _/           _/        _/    _/    _/      _/        _/    _/
     _/_/      _/_/_/      _/        _/_/_/             _/_/_/  _/    _/      _/_/  _/          _/_/_/
                                                                                                   _/
                                                                                              _/_/

Lasso

local(lasso = "
---------------------------------------------------------------
|    ,--,                                                      |
| ,---.'|                                           ,----..    |
| |   | :      ,---,       .--.--.    .--.--.      /   /   \\   |
| :   : |     '  .' \\     /  /    '. /  /    '.   /   .     :  |
| |   ' :    /  ;    '.  |  :  /`. /|  :  /`. /  .   /   ;.  \\ |
| ;   ; '   :  :       \\ ;  |  |--` ;  |  |--`  .   ;   /  ` ; |
| '   | |__ :  |   /\\   \\|  :  ;_   |  :  ;_    ;   |  ; \\ ; | |
| |   | :.'||  :  ' ;.   :\\  \\    `. \\  \\    `. |   :  | ; | ' |
| '   :    ;|  |  ;/  \\   \\`----.   \\ `----.   \\.   |  ' ' ' : |
| |   |  ./ '  :  | \\  \\ ,'__ \\  \\  | __ \\  \\  |'   ;  \\; /  | |
| ;   : ;   |  |  '  '--' /  /`--'  //  /`--'  / \\   \\  ',  /  |
| |   ,/    |  :  :      '--'.     /'--'.     /   ;   :    /   |
| '---'     |  | ,'        `--'---'   `--'---'     \\   \\ .'    |
|           `--''                                   `---`      |
----------------------------------------------------------------
")

stdoutnl(#lasso)

---------------------------------------------------------------
|    ,--,                                                      |
| ,---.'|                                           ,----..    |
| |   | :      ,---,       .--.--.    .--.--.      /   /   \   |
| :   : |     '  .' \     /  /    '. /  /    '.   /   .     :  |
| |   ' :    /  ;    '.  |  :  /`. /|  :  /`. /  .   /   ;.  \ |
| ;   ; '   :  :       \ ;  |  |--` ;  |  |--`  .   ;   /  ` ; |
| '   | |__ :  |   /\   \|  :  ;_   |  :  ;_    ;   |  ; \ ; | |
| |   | :.'||  :  ' ;.   :\  \    `. \  \    `. |   :  | ; | ' |
| '   :    ;|  |  ;/  \   \`----.   \ `----.   \.   |  ' ' ' : |
| |   |  ./ '  :  | \  \ ,'__ \  \  | __ \  \  |'   ;  \; /  | |
| ;   : ;   |  |  '  '--' /  /`--'  //  /`--'  / \   \  ',  /  |
| |   ,/    |  :  :      '--'.     /'--'.     /   ;   :    /   |
| '---'     |  | ,'        `--'---'   `--'---'     \   \ .'    |
|           `--''                                   `---`      |
----------------------------------------------------------------

Lua

io.write(" /$$\n")
io.write("| $$\n")
io.write("| $$       /$$   /$$  /$$$$$$\n")
io.write("| $$      | $$  | $$ |____  $$\n")
io.write("| $$      | $$  | $$  /$$$$$$$\n")
io.write("| $$      | $$  | $$ /$$__  $$\n")
io.write("| $$$$$$$$|  $$$$$$/|  $$$$$$$\n")
io.write("|________/ \______/  \_______/\n")
Output:
 /$$
| $$
| $$       /$$   /$$  /$$$$$$
| $$      | $$  | $$ |____  $$
| $$      | $$  | $$  /$$$$$$$
| $$      | $$  | $$ /$$__  $$
| $$$$$$$$|  $$$$$$/|  $$$$$$$
|________/ ______/  _______/

Alternate: 

print[[
 __
/\ \
\ \ \      __  __    ____    
 \ \ \    /\ \/\ \  / __ \
  \ \ \___\ \ \_\ \/\ \_\ \_
   \ \____\\ \____/\ \___/\_\
    \/____/ \/___/  \/__/\/_/]]
Output:
 __
/\ \
\ \ \      __  __    ____
 \ \ \    /\ \/\ \  / __ \
  \ \ \___\ \ \_\ \/\ \_\ \_
   \ \____\\ \____/\ \___/\_\
    \/____/ \/___/  \/__/\/_/

Mathematica/Wolfram Language

No hardcoding at all! 

locs = Position[
   ImageData[Binarize[Rasterize["Mathematica", ImageSize -> 150]]], 0];
Print[StringRiffle[
   StringJoin /@ 
    ReplacePart[
     ReplacePart[
      ConstantArray[
       " ", {Max[locs[[All, 1]]] + 1, Max[locs[[All, 2]]] + 1}], 
      locs -> "\\"], Map[# + 1 &, locs, {2}] -> "#"], "\n"]];
Output:
                                                                                                                                                      
                                                                                                                                                      
                                                                                                                                                      
                                                                                                                                                      
                                                                                                                                                      
                                           \\\                                                                     \\                                 
                                           \###                                                                    \##                                
 \\\\     \\\\                  \           ###                                                     \               ##                                
  ####   \\####                 \#          \##                                                     \#                                                
   \##   \####    \\\\\\      \\\#\\\\\     \##\\\\        \\\\\\    \\\\\\ \\\\     \\\\\\\      \\\#\\\\       \\\\          \\\\\ \      \\\\\\    
  \\### \\#\##   \\######      #########    \##\####      \\######    ######\####   \\#######      ########       ####        \\#####\#    \\######   
  \##\# \##\##    ##   \#       \#          \####  ##    \\##    ##   \### ### ##    ##    \#       \#              \#       \\##   ###     ##   \#   
  \##\##\# \##         \##      \#          \##    \#    \##     \##  \##  \#  \#          \##      \#              \#       \##    \##          \##  
  \## ##\# \##    \\\\\\##      \#          \##    \#    \##      ##  \##  \#  \#    \\\\\\\##      \#              \#       \##     ##     \\\\\\##  
  \## \#\# \##   \\#######      \#          \##    \#    \#\\\\\\\\#  \##  \#  \#   \\########      \#              \#      \\#            \\#######  
  \## \### \##  \\##   \##      \#          \##    \#    \##########  \##  \#  \#  \\##    \##      \#              \#       ##           \\##   \##  
  \#   ##  \##  \##    \##      \#          \##    \#    \#           \##  \#  \#  \##     \##      \#              \#       \#      \    \##    \##  
  \#       \##   ##  \\\##      \#    \\    \##    \#     #\     \\\  \##  \#  \#   ##   \\\##      \#   \\         \#        ##   \\\#    ##  \\\##  
 \\#\\   \\\##\   #\\\####\      ##\\\\##  \\##  \\\#\     ##\\\\\###\\##  \#  \#\   #\\\\####\      ##\\\##   \\\\\\#\\\      ##\\\###     #\\\####\ 
  #####   ######   #### ####      ######    ####  #####     #######   ####  ##  ###   ##### ####      #####     ##########      #####        #### ####

MiniScript

Nothing fancy here, but in keeping with MiniScript's "clear and simple" ethos: 

data = [
" ______  _____                       _________",
"|\     \/     \  ___  ________   ___|\   _____\ ________  ________  ___  ________  _________   ",
"\ \   _ \  _   \|\  \|\   ___  \|\  \ \  \____||\   ____\|\   ____\|\  \|\   __  \|\___   ___\ ",
" \ \  \\\__\ \  \ \  \ \  \\ \  \ \  \ \_____  \ \  \___|\ \  \___|\ \  \ \  \|\  \|___ \  \_| ",
"  \ \  \\|__| \  \ \  \ \  \\ \  \ \  \|____|\  \ \  \    \ \  \    \ \  \ \   ____\   \ \  \  ",
"   \ \  \    \ \  \ \  \ \  \\ \  \ \  \____\_\  \ \  \____\ \  \    \ \  \ \  \___|    \ \  \ ",
"    \ \__\    \ \__\ \__\ \__\\ \__\ \__\_________\ \_______\ \__\    \ \__\ \__\        \ \__\",
"     \|__|     \|__|\|__|\|__| \|__|\|__||________|\|_______|\|__|     \|__|\|__|         \|__|"]

for line in data
    print line
end for
Output:
 ______  _____                       _________
|\     \/     \  ___  ________   ___|\   _____\ ________  ________  ___  ________  _________   
\ \   _ \  _   \|\  \|\   ___  \|\  \ \  \____||\   ____\|\   ____\|\  \|\   __  \|\___   ___\ 
 \ \  \\\__\ \  \ \  \ \  \\ \  \ \  \ \_____  \ \  \___|\ \  \___|\ \  \ \  \|\  \|___ \  \_| 
  \ \  \\|__| \  \ \  \ \  \\ \  \ \  \|____|\  \ \  \    \ \  \    \ \  \ \   ____\   \ \  \  
   \ \  \    \ \  \ \  \ \  \\ \  \ \  \____\_\  \ \  \____\ \  \    \ \  \ \  \___|    \ \  \ 
    \ \__\    \ \__\ \__\ \__\\ \__\ \__\_________\ \_______\ \__\    \ \__\ \__\        \ \__\
     \|__|     \|__|\|__|\|__| \|__|\|__||________|\|_______|\|__|     \|__|\|__|         \|__|

Modula-2

MODULE Art;
FROM Terminal IMPORT WriteString,WriteLn,ReadChar;

BEGIN
    (* 3D, but does not fit in the terminal window *)
    (*
    WriteString("_____ ______   ________  ________  ___  ___  ___       ________                   _______");
    WriteLn;
    WriteString("|\   _ \  _   \|\   __  \|\   ___ \|\  \|\  \|\  \     |\   __  \                 /  ___  \");
    WriteLn;
    WriteString("\ \  \\\__\ \  \ \  \|\  \ \  \_|\ \ \  \\\  \ \  \    \ \  \|\  \  ____________ /__/|_/  /|");
    WriteLn;
    WriteString(" \ \  \\|__| \  \ \  \\\  \ \  \ \\ \ \  \\\  \ \  \    \ \   __  \|\____________\__|//  / /");
    WriteLn;
    WriteString("  \ \  \    \ \  \ \  \\\  \ \  \_\\ \ \  \\\  \ \  \____\ \  \ \  \|____________|   /  /_/__");
    WriteLn;
    WriteString("   \ \__\    \ \__\ \_______\ \_______\ \_______\ \_______\ \__\ \__\               |\________\");
    WriteLn;
    WriteString("    \|__|     \|__|\|_______|\|_______|\|_______|\|_______|\|__|\|__|                \|_______|");
    WriteLn;
    *)

    (* Not 3D, but fits in the terminal window *)
    WriteString("  __  __           _       _            ___");
    WriteLn;
    WriteString(" |  \/  |         | |     | |          |__ \");
    WriteLn;
    WriteString(" | \  / | ___   __| |_   _| | __ _ ______ ) |");
    WriteLn;
    WriteString(" | |\/| |/ _ \ / _` | | | | |/ _` |______/ /");
    WriteLn;
    WriteString(" | |  | | (_) | (_| | |_| | | (_| |     / /_");
    WriteLn;
    WriteString(" |_|  |_|\___/ \__,_|\__,_|_|\__,_|    |____|");
    WriteLn;

    ReadChar
END Art.

Nanoquery

println " ________   ________  ________   ________  ________  ___  ___  _______   ________      ___    ___     "
println "|\\   ___  \\|\\   __  \\|\\   ___  \\|\\   __  \\|\\   __  \\|\\  \\|\\  \\|\\  ___ \\ |\\   __  \\    |\\  \\  /  /|    "
println "\\ \\  \\\\ \\  \\ \\  \\|\\  \\ \\  \\\\ \\  \\ \\  \\|\\  \\ \\  \\|\\  \\ \\  \\\\\\  \\ \\   __/|\\ \\  \\|\\  \\   \\ \\  \\/  / /    "
println " \\ \\  \\\\ \\  \\ \\   __  \\ \\  \\\\ \\  \\ \\  \\\\\\  \\ \\  \\\\\\  \\ \\  \\\\\\  \\ \\  \\_|/_\\ \\   _  _\\   \\ \\    / /     "
println "  \\ \\  \\\\ \\  \\ \\  \\ \\  \\ \\  \\\\ \\  \\ \\  \\\\\\  \\ \\  \\\\\\  \\ \\  \\\\\\  \\ \\  \\_|\\ \\ \\  \\\\  \\|   \\/  /  /      "
println "   \\ \\__\\\\ \\__\\ \\__\\ \\__\\ \\__\\\\ \\__\\ \\_______\\ \\_____  \\ \\_______\\ \\_______\\ \\__\\\\ _\\ __/  / /        "
println "    \\|__| \\|__|\\|__|\\|__|\\|__| \\|__|\\|_______|\\|___| \\__\\|_______|\\|_______|\\|__|\\|__|\\___/ /         "
println "                                                    \\|__|                            \\|___|/          "
Output:
 ________   ________  ________   ________  ________  ___  ___  _______   ________      ___    ___
|\   ___  \|\   __  \|\   ___  \|\   __  \|\   __  \|\  \|\  \|\  ___ \ |\   __  \    |\  \  /  /|
\ \  \\ \  \ \  \|\  \ \  \\ \  \ \  \|\  \ \  \|\  \ \  \\\  \ \   __/|\ \  \|\  \   \ \  \/  / /
 \ \  \\ \  \ \   __  \ \  \\ \  \ \  \\\  \ \  \\\  \ \  \\\  \ \  \_|/_\ \   _  _\   \ \    / /
  \ \  \\ \  \ \  \ \  \ \  \\ \  \ \  \\\  \ \  \\\  \ \  \\\  \ \  \_|\ \ \  \\  \|   \/  /  /
   \ \__\\ \__\ \__\ \__\ \__\\ \__\ \_______\ \_____  \ \_______\ \_______\ \__\\ _\ __/  / /
    \|__| \|__|\|__|\|__|\|__| \|__|\|_______|\|___| \__\|_______|\|_______|\|__|\|__|\___/ /
                                                    \|__|                            \|___|/

NetRexx

Based on an idea found in the Scala version. 

/* NetRexx */
options replace format comments java crossref symbols nobinary

txt = '';
x = 0
x = x + 1; txt[0] = x; txt[x] = '   *    *            *****'
x = x + 1; txt[0] = x; txt[x] = '   **   *        *   *    *'
x = x + 1; txt[0] = x; txt[x] = '   * *  *  ***  ***  *    *  ***  *   * *   *'
x = x + 1; txt[0] = x; txt[x] = '   *  * * *   *  *   *****  *   *  * *   * *'
x = x + 1; txt[0] = x; txt[x] = '   *   ** *****  *   *  *   *****   *     *'
x = x + 1; txt[0] = x; txt[x] = '   *    * *      *   *   *  *      * *   * *'
x = x + 1; txt[0] = x; txt[x] = '   *    *  ***    ** *    *  ***  *   * *   *'
x = x + 1; txt[0] = x; txt[x] = ''

_top = '_TOP'
_bot = '_BOT'
txt = Banner3D(txt, isTrue())
loop ll = 1 to txt[0]
  say txt[ll, _top]
  say txt[ll, _bot]
  end ll

return

method Banner3D(txt, slope = '') public static

  select
    when slope = isTrue() then nop
    when slope = isFalse() then nop
    otherwise do
      if slope = '' then slope = isFalse()
                    else slope = isTrue()
      end
    end

  _top = '_TOP'
  _bot = '_BOT'
  loop ll = 1 to txt[0]
    txt[ll, _top] = txt[ll]
    txt[ll, _bot] = txt[ll]
    txt[ll, _top] = txt[ll, _top].changestr(' ', '   ')
    txt[ll, _bot] = txt[ll, _bot].changestr(' ', '   ')
    txt[ll, _top] = txt[ll, _top].changestr('*', '///')
    txt[ll, _bot] = txt[ll, _bot].changestr('*', '\\\\\\')
    txt[ll, _top] = txt[ll, _top] || ' '
    txt[ll, _bot] = txt[ll, _bot] || ' '
    txt[ll, _top] = txt[ll, _top].changestr('/ ', '/\\')
    txt[ll, _bot] = txt[ll, _bot].changestr('\\ ', '\\/')
    end ll

  if slope then do
    loop li = txt[0] to 1 by -1
      ll = txt[0] - li + 1
      txt[ll, _top] = txt[ll, _top].insert('', 1, li - 1, ' ')
      txt[ll, _bot] = txt[ll, _bot].insert('', 1, li - 1, ' ')
      end li
    end

  return txt

method isTrue public constant binary returns boolean
  return 1 == 1

method isFalse public constant binary returns boolean
  return \isTrue()
Output:
                ///\           ///\                                   ///////////////\ 
                \\\/           \\\/                                   \\\\\\\\\\\\\\\/ 
               //////\        ///\                       ///\        ///\           ///\ 
               \\\\\\/        \\\/                       \\\/        \\\/           \\\/ 
              ///\  ///\     ///\     /////////\     /////////\     ///\           ///\     /////////\     ///\        ///\  ///\        ///\ 
              \\\/  \\\/     \\\/     \\\\\\\\\/     \\\\\\\\\/     \\\/           \\\/     \\\\\\\\\/     \\\/        \\\/  \\\/        \\\/ 
             ///\     ///\  ///\  ///\        ///\     ///\        ///////////////\     ///\        ///\     ///\  ///\        ///\  ///\ 
             \\\/     \\\/  \\\/  \\\/        \\\/     \\\/        \\\\\\\\\\\\\\\/     \\\/        \\\/     \\\/  \\\/        \\\/  \\\/ 
            ///\        //////\  ///////////////\     ///\        ///\     ///\        ///////////////\        ///\              ///\ 
            \\\/        \\\\\\/  \\\\\\\\\\\\\\\/     \\\/        \\\/     \\\/        \\\\\\\\\\\\\\\/        \\\/              \\\/ 
           ///\           ///\  ///\                 ///\        ///\        ///\     ///\                 ///\  ///\        ///\  ///\ 
           \\\/           \\\/  \\\/                 \\\/        \\\/        \\\/     \\\/                 \\\/  \\\/        \\\/  \\\/ 
          ///\           ///\     /////////\           //////\  ///\           ///\     /////////\     ///\        ///\  ///\        ///\ 
          \\\/           \\\/     \\\\\\\\\/           \\\\\\/  \\\/           \\\/     \\\\\\\\\/     \\\/        \\\/  \\\/        \\\/

Nim

Translation of: Python
import strutils

const nim = """
            #    #   #####   #    #
            ##   #     #     ##  ##
            # #  #     #     # ## #
            #  # #     #     #    #
            #   ##     #     #    #
            #    #   #####   #    #
            """
let lines = nim.dedent.multiReplace(("#", "<<<"), (" ", "   "), ("< ", "<>"), ("<\n", "<>\n")).splitLines
for i, line in lines:
  echo spaces(lines.len - i), line
Output:
       <<<            <<<         <<<<<<<<<<<<<<<         <<<            <<<
      <<<<<<         <<<               <<<               <<<<<<      <<<<<<
     <<<   <<<      <<<               <<<               <<<   <<<<<<   <<<
    <<<      <<<   <<<               <<<               <<<            <<<
   <<<         <<<<<<               <<<               <<<            <<<
  <<<            <<<         <<<<<<<<<<<<<<<         <<<            <<<

OCaml

 print_string   "   
                    _|_|_|    _|_|_|       _|_|       _|_|   _|_|  _|
                   _|    _|  _|           _|   _|     _| _| _| _|  _|
                   _|    _|  _|          _|_|_| _|    _|  _|   _|  _|
                   _|    _|  _|         _|       _|   _|       _|  _|
                    _|_|_|    _|_|_|   _|         _|  _|       _|  _|_|_|_|_|
                                                                              "
Output:

                    _|_|_|    _|_|_|       _|_|       _|_|   _|_|  _|
                   _|    _|  _|           _|   _|     _| _| _| _|  _|
                   _|    _|  _|          _|_|_| _|    _|  _|   _|  _|
                   _|    _|  _|         _|       _|   _|       _|  _|
                    _|_|_|    _|_|_|   _|         _|  _|       _|  _|_|_|_|_|

Pascal

program WritePascal;

const
  i64: int64 = 1055120232691680095; (* This defines "Pascal" *)
  cc: array[-1..15] of string = (* Here are all string-constants *)
    ('_______v---',
    '__', '\_', '___', '\__',
    '  ', '  ', '   ', '   ',
    '/ ', '  ', '_/ ', '\/ ',
    ' _', '__', '  _', '  _');
var
  x, y: integer;

begin
  for y := 0 to 7 do
  begin
    Write(StringOfChar(cc[(not y and 1) shl 2][1], 23 - y and 6));
    Write(cc[((i64 shr (y div 2)) and 1) shl 3 + (not y and 1) shl 2 + 2]);
    for x := 0 to 15 do
      Write(cc[((i64 shr ((x and 15) * 4 + y div 2)) and 1) +
        ((i64 shr (((x + 1) and 15) * 4 + y div 2)) and 1) shl 3 +
        (x mod 3) and 2 + (not y and 1) shl 2]);
    writeln(cc[1 + (not y and 1) shl 2] + cc[(not y and 1) shl 3 - 1]);
  end;
end.

Need 64-Bit Integer for this solution. My goal was to do a straight-forward solution, (Just two nested loops, no conditional code). All characters in one place.

Output:
                         _____                                _
________________________/     \______________________________/ \________v---
                       _   _    ___    ___    _      ___    _
______________________/ \_/ \__/   \__/   \__/ \____/   \__/ \________v---
                     ___    _   _    _    _      _   _    _
____________________/   \__/ \_/ \__/ \__/ \____/ \_/ \__/ \________v---
                   _        ___  ___      ___    ___    _
__________________/ \______/   \/   \____/   \__/   \__/ \________v---

Perl

#!/usr/bin/perl
use strict;
use warnings;

for my $tuple ([" ", 2], ["_", 1], [" ", 1], ["\\", 1], [" ", 11], ["|", 1], ["\n", 1],
               [" ", 1], ["|", 1], [" ", 3], ["|", 1],  [" ", 1],  ["_", 1], [" ", 1], ["\\", 1], [" ", 2], ["_", 2], ["|", 1], [" ", 1], ["|", 1], ["\n", 1],
               [" ", 1], ["_", 3], ["/", 1], [" ", 2],  ["_", 2],  ["/", 1], [" ", 1], ["|", 1],  [" ", 4], ["|", 1], ["\n", 1],
               ["_", 1], ["|", 1], [" ", 3], ["\\", 1], ["_", 3],  ["|", 1], ["_", 1], ["|", 1],  [" ", 3], ["_", 1], ["|", 1], ["\n", 1]
              ) {
    print $tuple->[0] x $tuple->[1];
}
Output:
  _ \           |
 |   | _ \  __| |
 ___/  __/ |    |
_|   \___|_|   _|

Font taken from http://www.network-science.de/ascii/.

Phix

constant s = """
------***  *
-----*  * *
----*  * *   *
---***  *
--*    *** * * *
-*    * * *  *
*    * * * * *
"""
puts(1,substitute_all(s,"* ",{"_/","  "}))
Output:
------_/_/_/    _/
-----_/    _/  _/
----_/    _/  _/      _/
---_/_/_/    _/
--_/        _/_/_/  _/  _/  _/
-_/        _/  _/  _/    _/
_/        _/  _/  _/  _/  _/

obfuscated

For those of you who like this sort of thing, same output 

constant q = {0(30)10C,0(31)176,0(32)2A4,0(33)6N3,0(34)7GP,0(35)DWF,0(36)QC4}
puts(1,substitute_all(sprintf(join(repeat("%16b",7),"\n"),q)," 10",{"-","_/","  "})&"\n")

another version

Inspired by Ruby 

puts(1,"""
   __    ________
  /_/\  / ______ \
  \ \ \/ /\____/ /\ __
   \ \ \/ /   / / //_/\
    \ \ \/___/ / / \_\/_  __
    /\ \______/ /    /_/\/ /\
   / /\  ____ \ \    \ \ \/ /
  / / /\ \ \ \ \ \    \_\  /
 / / /  \ \ \ \ \ \   / /  \
/_/ /    \ \ \ \ \ \ /_/ /\ \
\_\/      \_\/  \_\/ \_\/\_\/
""")
-- or if you prefer something a little more cryptic (same output):
puts(1,"   __    ________\n  /_/\\  / ______ \\\n  \\ \\ \\/ /\\____/ /\\ __\n   "&
       "\\ \\ \\/ /   / / //_/\\\n    \\ \\ \\/___/ / / \\_\\/_  __\n    /\\ \\__"&
       "____/ /    /_/\\/ /\\\n   / /\\  ____ \\ \\    \\ \\ \\/ /\n  / / /\\ \\ "&
       "\\ \\ \\ \\    \\_\\  /\n / / /  \\ \\ \\ \\ \\ \\   / /  \\\n/_/ /    \\"&
       " \\ \\ \\ \\ \\ /_/ /\\ \\\n\\_\\/      \\_\\/  \\_\\/ \\_\\/\\_\\/\n")

PicoLisp

Translation of: Tcl
(de Lst
   "*****             *               "
   "*   * *           *    *          "
   "*   *   **** **** *      **** ****"
   "***** * *    *  * *    * *  * *  *"
   "*     * *    *  * *    *  *   ****"
   "*     * *    *  * *    *   *  *   "
   "*     * *    *  * *    * *  * *   "
   "*     * **** **** **** * **** *   " )

(de transform (Lst A B)
   (make
      (chain (need (length Lst) " "))
      (for (L (chop (car Lst)) L)
         (ifn (= "*" (pop 'L))
            (link " " " " " ")
            (chain (need 3 A))
            (when (sp? (car L))
               (link B " " " ")
               (pop 'L) ) ) ) ) )

(prinl (transform Lst "/" "\\"))

(mapc
   '((X Y)
      (mapc
         '((A B)
            (prin (if (sp? B) A B)) )
            X
            Y )
      (prinl) )
   (maplist '((X) (transform X "\\" "/")) Lst)
   (maplist '((X) (transform X "/" "\\")) (cdr Lst)) )

(bye)
Output:
        ///////////////\                                      ///\
       ///\\\\\\\\\///\/ ///\                                ///\/          ///\
      ///\/       ///\/  \\\/ ////////////\  ////////////\  ///\/           \\\/ ////////////\  ////////////\
     ///////////////\/ ///\  ///\\\\\\\\\\/ ///\\\\\\///\/ ///\/          ///\  ///\\\\\\///\/ ///\\\\\\///\/
    ///\\\\\\\\\\\\\/ ///\/ ///\/          ///\/    ///\/ ///\/          ///\/  \\///\   \\\/ ////////////\/
   ///\/             ///\/ ///\/          ///\/    ///\/ ///\/          ///\/     \\///\     ///\\\\\\\\\\/
  ///\/             ///\/ ///\/          ///\/    ///\/ ///\/          ///\/ ///\   \\///\  ///\/
 ///\/             ///\/ ////////////\  ////////////\/ ////////////\  ///\/ ////////////\/ ///\/
 \\\/              \\\/  \\\\\\\\\\\\/  \\\\\\\\\\\\/  \\\\\\\\\\\\/  \\\/  \\\\\\\\\\\\/  \\\/

Plain English

To run:
Start up.
Print the language name in 3D ASCII.
Wait for the escape key.
Shut down.

To print the language name in 3D ASCII:
Write "Osmosian Order of" to the console.
Write " ____   _           _" to the console.  
Write "/___ \ /_/|        /_/|" to the console.
Write "|   \ \| ||   ____ |_|/ _____" to the console.
Write "| |\ \|| ||  /___/| _  /____/\" to the console.
Write "| | | || || /    ||/_/||    \ \" to the console.
Write "| |/ / | ||/  /| ||| ||| |\  \/" to the console.
Write "| __/  | ||| | | ||| ||| | | ||" to the console.
Write "| ||   | ||\  \| ||| ||| | | ||" to the console.
Write "|_|/   |_|/ \____|/|_|/|_| |_|/" to the console.
Write " ______                  _   _           _" to the console.
Write "/_____/|                /_/|/_/|        /_/|" to the console.
Write "|  ___|/ _____     ____ | |||_|/ _______| ||__" to the console.
Write "| ||___ /____/\   /___/|| || _  /______/| /__/\" to the console.
Write "| |/__/||    \ \ /    ||| ||/_/|/  ___|/|    \ \" to the console.
Write "|  ___|/| |\  \//  /| ||| ||| ||| |___/\| |\  \/" to the console.
Write "| ||___ | | | ||| | | ||| ||| ||\____ \|| | | ||" to the console.
Write "| |/__/|| | | ||\  \| ||| ||| ||____|  || | | ||" to the console.
Write "|_____|/|_| |_|/ \__  |||_|/|_|/|_____/ |_| |_|/" to the console.
Write "                 ___| ||" to the console.
Write "                /___/ //" to the console.
Write "                |____//" to the console.
Write "Programmers" to the console.
Output:
Osmosian Order of
 ____   _           _
/___ \ /_/|        /_/|
|   \ \| ||   ____ |_|/ _____
| |\ \|| ||  /___/| _  /____/\
| | | || || /    ||/_/||    \ \
| |/ / | ||/  /| ||| ||| |\  \/
| __/  | ||| | | ||| ||| | | ||
| ||   | ||\  \| ||| ||| | | ||
|_|/   |_|/ \____|/|_|/|_| |_|/
 ______                  _   _           _
/_____/|                /_/|/_/|        /_/|
|  ___|/ _____     ____ | |||_|/ _______| ||__
| ||___ /____/\   /___/|| || _  /______/| /__/\
| |/__/||    \ \ /    ||| ||/_/|/  ___|/|    \ \
|  ___|/| |\  \//  /| ||| ||| ||| |___/\| |\  \/
| ||___ | | | ||| | | ||| ||| ||\____ \|| | | ||
| |/__/|| | | ||\  \| ||| ||| ||____|  || | | ||
|_____|/|_| |_|/ \__  |||_|/|_|/|_____/ |_| |_|/
                 ___| ||
                /___/ //
                |____//
Programmers

PureBasic

If OpenConsole()
  PrintN("   ////\                           ////\                   ////|          ") 
  PrintN("  ////  \                     __  ////  \      __         |XX|_/          ") 
  PrintN(" //// /| |   ////\   ////\////  |//// /| | ////  |  ////\          ////\  ") 
  PrintN("|XX| |X| ////\X| ////\// //// /||XX| |X| |//// /|| //// _| ////\  ////  \ ") 
  PrintN("|XX| |X||XX| |X||XX| |/ |XX| |X||XX| |/ /|XX| |X||//// /  |XX| | //// /\ |") 
  PrintN("|XX| |/ |XX| |X||XX|   /|XX| |//|XX|    \|XX|/// |XX| |/\ |XX| ||XX| |XX\|") 
  PrintN("|XX|   /|XX| |X||XX|  / |XX|  //|XX|  /| |////   |XX|    ||XX| ||XX| |    ") 
  PrintN("|$$|  / |$$| |&||$$| |  |$$| |&||$$| |&| |$$|  /||\\\\/| ||$$| ||$$| |///|") 
  PrintN("|%%| |  |%%| |i||%%| |  |%%| |/ |%%| |i| |%%| |i||  |%%| ||%%| ||%%| |// |") 
  PrintN("|ii| |  |ii| |/ |ii| |  |ii|   /|ii| |/ /|ii| \/|/  |ii| /|ii| ||ii| |/ / ") 
  PrintN("|::| |   \\\\  /|::| |  |::|  / |::|   / |::|  /   //// / |::| | \\\\  /  ") 
  PrintN("|..| |    \\\\/ |..|/    \\\\/  |..|  /   \\\\/   \\\\ /  |..|/   \\\\/   ") 
  PrintN(" \\\\|                           \\\\/                                    ") 
  
  Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()
  CloseConsole()
EndIf

Sample output: 

   ////\                           ////\                   ////|
  ////  \                     __  ////  \      __         |XX|_/
 //// /| |   ////\   ////\////  |//// /| | ////  |  ////\          ////\
|XX| |X| ////\X| ////\// //// /||XX| |X| |//// /|| //// _| ////\  ////  \
|XX| |X||XX| |X||XX| |/ |XX| |X||XX| |/ /|XX| |X||//// /  |XX| | //// /\ |
|XX| |/ |XX| |X||XX|   /|XX| |//|XX|    \|XX|/// |XX| |/\ |XX| ||XX| |XX\|
|XX|   /|XX| |X||XX|  / |XX|  //|XX|  /| |////   |XX|    ||XX| ||XX| |
|$$|  / |$$| |&||$$| |  |$$| |&||$$| |&| |$$|  /||\\\\/| ||$$| ||$$| |///|
|%%| |  |%%| |i||%%| |  |%%| |/ |%%| |i| |%%| |i||  |%%| ||%%| ||%%| |// |
|ii| |  |ii| |/ |ii| |  |ii|   /|ii| |/ /|ii| \/|/  |ii| /|ii| ||ii| |/ /
|::| |   \\\\  /|::| |  |::|  / |::|   / |::|  /   //// / |::| | \\\\  /
|..| |    \\\\/ |..|/    \\\\/  |..|  /   \\\\/   \\\\ /  |..|/   \\\\/
 \\\\|                           \\\\/

Python

Implementation 1: based on the Scala type idea of 'fleshing out' a 2D banner version. 

py = '''\
 ####   #   #  #####  #   #   ###   #   #
 #   #   # #     #    #   #  #   #  ##  #
 ####     #      #    #####  #   #  # # #
 #        #      #    #   #  #   #  #  ##
 #        #      #    #   #   ###   #   #'''

lines = py.replace('#', '<<<').replace(' ','X') \
        .replace('X', '   ').replace('\n', ' Y') \
        .replace('< ', '<>').split('Y')

for i, l in enumerate(lines): 
    print('  ' * (len(lines) - i) + l)
Output:
             <<<<<<<<<<<<>        <<<>        <<<>     <<<<<<<<<<<<<<<>     <<<>        <<<>        <<<<<<<<<>        <<<>        <<<>
           <<<>        <<<>        <<<>  <<<>              <<<>           <<<>        <<<>     <<<>        <<<>     <<<<<<>     <<<>
         <<<<<<<<<<<<>              <<<>                 <<<>           <<<<<<<<<<<<<<<>     <<<>        <<<>     <<<>  <<<>  <<<>
       <<<>                       <<<>                 <<<>           <<<>        <<<>     <<<>        <<<>     <<<>     <<<<<<>
     <<<>                       <<<>                 <<<>           <<<>        <<<>        <<<<<<<<<>        <<<>        <<<

Implementation 2: 

charWidth = 10
charHeight = 8

# char table is split into sets to prevent very long lines...
charSet1 = [
"   ######  /#######    ######  /######   /######## /########   ######  /##   /##",
" /##__  ##| ##__  ## /##__  ##| ##__ ## | ##_____/| ##_____/ /##__  ##| ##  | ##",
"| ##  | ##| ##  | ##| ##  \__/| ##  \ ##| ##      | ##      | ##  \__/| ##  | ##",
"| ########| ####### | ##      | ##  | ##| ########| ########| ## #####| ########",
"| ##__  ##| ##__  ##| ##      | ##  | ##| ##_____/| ##_____/| ##|_  ##| ##__  ##",
"| ##  | ##| ##  | ##| ##   /##| ##  /##/| ##      | ##      | ##  | ##| ##  | ##",
"| ##  | ##| #######/|  ######/| ######/ | ########| ##      |  ######/| ##  | ##",
"|__/  |__/|_______/  \______/ |______/  |________/|__/       \______/ |__/  |__/",
]

charSet2 = [
" /########       /## /##   /## /##       /###  ### /##   /##   ######  /####### ",
"|__  ##__/      | ##| ##  /##/| ##      | ########| ### | ## /##__  ##| ##__  ##",
"   | ##         | ##| ## /##/ | ##      | ## ## ##| ####| ##| ##  | ##| ##  | ##",
"   | ##         | ##| #####/  | ##      | ## ## ##| ## ## ##| ##  | ##| #######/",
"   | ##         | ##| ##  ##  | ##      | ## ## ##| ##  ####| ##  | ##| ##____/ ",
"   | ##    /##  | ##| ##\  ## | ##      | ##__/ ##| ##\  ###| ##  | ##| ##      ",
" /########\  ######/| ## \  ##| ########| ##  | ##| ## \  ##|  ######/| ##      ",
"|________/ \______/ |__/  \__/|________/|__/  |__/|__/  \__/ \______/ |__/      ",
]

charSet3 = [
"   ######  /#######    ######  /######## /##   /## /##   /## /##   /## /##   /##",
" /##__  ##| ##__  ## /##__  ##|__  ##__/| ##  | ##| ##  | ##| ##  | ##\  ## /##/",
"| ##  | ##| ##  | ##| ##  \__/   | ##   | ##  | ##| ##  | ##| ## ## ## \  ####/ ",
"| ##  | ##| #######/ \ ######    | ##   | ##  | ##| ##  | ##| ## ## ##  \  ##/  ",
"| ## ## ##| ##  ##    \___  ##   | ##   | ##  | ##|  ##  ##/| ## ## ##  / ####  ",
"| ##\ ###/| ##\  ##  /##  \ ##   | ##   | ##  | ## \  ####/ | ######## / ##  ## ",
"|  #### ##| ## \  ##\  ######/   | ##   |  ######/  \  ##/  | ###| ###/ ## \  ##",
" \____\__/|__/  \__/ \______/    |__/    \______/    \__/   |___/|___/\__/  \__/",
]

charSet4 = [
" /##   /## /########   ######           ",
"\  ## /##/|____  ##/ /##__  ##          ",
" \  ####/     / ##/ | ##  | ##          ",
"  \  ##/     / ##/  |__//####/          ",
"   | ##     / ##/      | ##_/           ",
"   | ##    / ##/       |__/             ",
"   | ##   / ########    /##             ",
"   |__/   \________/   |__/             ",
]

# ...then the sets are combined back by barbequing them together!
charTable = [(charSet1[i] +
              charSet2[i] +
              charSet3[i] +
              charSet4[i]) for i in range(charHeight)]

if __name__ == '__main__':
    text = input("Enter the text to convert:\n")
    if not text: 
        text = "PYTHON"

    for i in range(charHeight):
        lineOut = ""
        for chr in text:
            # get value of character 'chr' in alphabet
            if chr.isalpha():
                val = ord(chr.upper()) - 65
            elif chr == " ":
                val= 27
            else:
                val = 26
            beginStr = val * charWidth   # begin string position of 3D letter
            endStr = (val + 1) * charWidth   # end string position of 3D letter
            lineOut += charTable[i][beginStr:endStr]
        print(lineOut)
Output:
 /#######  /##   /## /######## /##   /##   ######  /##   /##
| ##__  ##\  ## /##/|__  ##__/| ##  | ## /##__  ##| ### | ##
| ##  | ## \  ####/    | ##   | ##  | ##| ##  | ##| ####| ##
| #######/  \  ##/     | ##   | ########| ##  | ##| ## ## ##
| ##____/    | ##      | ##   | ##__  ##| ##  | ##| ##  ####
| ##         | ##      | ##   | ##  | ##| ##  | ##| ##\  ###
| ##         | ##      | ##   | ##  | ##|  ######/| ## \  ##
|__/         |__/      |__/   |__/  |__/ \______/ |__/  \__/

Implementation 3: a more general solution that scrapes http://www.network-science.de/ascii for the ASCII art. 

import requests
import html

text = "Python"
font = "larry3d"
url = f"http://www.network-science.de/ascii/ascii.php?TEXT={text}&FONT={font}&RICH=no&FORM=left&WIDT=1000"

r = requests.get(url)
r.raise_for_status()

ascii_text = html.unescape(r.text)
pre_ascii = "<TD><PRE>"
post_ascii = "\n</PRE>"
ascii_text = ascii_text[ascii_text.index(pre_ascii) + len(pre_ascii):]
ascii_text = ascii_text[:ascii_text.index(post_ascii)]

print(ascii_text)
Output:
 ____            __     __
/\  _`\         /\ \__ /\ \
\ \ \L\ \ __  __\ \ ,_\\ \ \___      ___     ___
 \ \ ,__//\ \/\ \\ \ \/ \ \  _ `\   / __`\ /' _ `\
  \ \ \/ \ \ \_\ \\ \ \_ \ \ \ \ \ /\ \L\ \/\ \/\ \
   \ \_\  \/`____ \\ \__\ \ \_\ \_\\ \____/\ \_\ \_\
    \/_/   `/___/> \\/__/  \/_/\/_/ \/___/  \/_/\/_/
              /\___/
              \/__/

Quackery

say " ________  ___  ___  ________  ________  ___  __    _______   ________  ___    ___" cr
say "|\   __  \|\  \|\  \|\   __  \|\   ____\|\  \|\  \ |\  ___ \ |\   __  \|\  \  /  /|" cr
say "\ \  \|\  \ \  \ \  \ \  \|\  \ \  \___|\ \  \/  /|\ \   __/|\ \  \|\  \ \  \/  / /" cr
say " \ \  \ \  \ \  \ \  \ \   __  \ \  \    \ \   ___  \ \  \_|/ \ \   _  _\ \    / /" cr
say "  \ \  \_\  \ \  \_\  \ \  \ \  \ \  \____\ \  \\ \  \ \  \__\_\ \  \\  \ /   / /" cr 
say "   \ \_____  \ \_______\ \__\ \__\ \_______\ \__\\ \__\ \_______\ \__\\ _\   / /" cr    
say "    \|___| \  \|_______|\|__|\|__|\|_______|\|__| \|__|\|_______|\|__|\|__| / /" cr   
say "          \ \  \_______________________________________________________/   / /" cr    
say "           \ \____________________________________________________________/ /" cr   
say "            \|____________________________________________________________|/" cr
Output:
 ________  ___  ___  ________  ________  ___  __    _______   ________  ___    ___
|\   __  \|\  \|\  \|\   __  \|\   ____\|\  \|\  \ |\  ___ \ |\   __  \|\  \  /  /|
\ \  \|\  \ \  \ \  \ \  \|\  \ \  \___|\ \  \/  /|\ \   __/|\ \  \|\  \ \  \/  / /
 \ \  \ \  \ \  \ \  \ \   __  \ \  \    \ \   ___  \ \  \_|/ \ \   _  _\ \    / /
  \ \  \_\  \ \  \_\  \ \  \ \  \ \  \____\ \  \\ \  \ \  \__\_\ \  \\  \ /   / /
   \ \_____  \ \_______\ \__\ \__\ \_______\ \__\\ \__\ \_______\ \__\\ _\   / /
    \|___| \  \|_______|\|__|\|__|\|_______|\|__| \|__|\|_______|\|__|\|__| / /
          \ \  \_______________________________________________________/   / /
           \ \____________________________________________________________/ /
            \|____________________________________________________________|/


Racket

Use the GUI to create a text banner: 

#lang racket/gui

;; Get the language name
(define str (cadr (regexp-match #rx"Welcome to (.*?) *v[0-9.]+\n*$" (banner))))

;; Font to use
(define font (make-object font% 12 "MiscFixed" 'decorative 'normal 'bold))
;; (get-face-list) -> get a list of faces to try in the above

;; Calculate the needed size (leave space for a drop-down shadow)
(define-values [W H]
  (let ([bdc (make-object bitmap-dc% (make-object bitmap% 1 1 #t))])
    (call-with-values
        (λ() (send* bdc (set-font font) (get-text-extent str font)))
        (λ(w h _1 _2) (values (+ 2 (inexact->exact (round w)))
                              (+ 2 (inexact->exact (round h))))))))

;; Draw the text
(define bmp (make-bitmap W H #t))
(define dc (send bmp make-dc))
(send* dc (set-font font) (draw-text str 2 0))

;; Grab the pixels as a string, 3d-ed with "/"s
(define scr
  (let* ([size (* W H 4)] [buf (make-bytes size)])
    (send bmp get-argb-pixels 0 0 W H buf)
    (define scr (make-string (* (add1 W) (add1 H)) #\space))
    (for ([i (in-range 0 size 4)] [j (* W H)]
          #:unless (zero? (bytes-ref buf i)))
      (string-set! scr j #\@)
      (for ([k (list j (+ j W -1))] [c "/."] #:when #t
            [k (list (- k 1) (+ k W) (+ k W -1))]
            #:when (and (< -1 k (string-length scr))
                        (member (string-ref scr k) '(#\space #\.))))
        (string-set! scr k c)))
    scr))

;; Show it, dropping empty lines
(let ([lines (for/list ([y H]) (substring scr (* y W) (* (add1 y) W)))])
  (define (empty? l) (not (regexp-match #rx"[^ ]" l)))
  (for ([line (dropf-right (dropf lines empty?) empty?)])
    (displayln (string-trim line #:left? #f))))
Output:
 /@@@@@@@                    /@@
./@@////@@                  ./@@                /@@
./@@.../@@                  ./@@               ./@@
./@@  ./@@  /@@@@@   /@@@@@ ./@@ /@@   /@@@@  /@@@@@@
./@@@@@@@/ /@@///@@ /@@///@@./@@/@@/  /@@//@@.///@@//
./@@@@@// .///../@@/@@/..///./@@@@/  /@@/.//@@../@@.
./@@//@@  ./@@@@@@@/@@  ... ./@@@@  ./@@@@@@@@ ./@@
./@@.//@@ /@@////@@/@@      ./@@/@@ ./@@////// ./@@
./@@..//@@/@@../@@@//@@  /@@./@@//@@.//@@../@@ ./@@ /@@
./@@ ../@@//@@@@/@@.//@@@@@/./@@.//@@.//@@@@@/ .//@@@@/
.///  .///.////////..////// .///..///..//////  ../////
...   ... ........  ......  ...  ...  ......    .....

Raku

(formerly Perl 6) Produces a good old-fashioned stereogram, meant to be looked at by focusing beyond the screen, not by crossing your eyes. If you can't get it to converge, try shrinking the font size till the images are closer together than your eyes. Also helps to be old enough to have progressive lenses, so you can look through the reading part of your glasses. Or borrow glasses from someone who's farsighted. :-) 

# must be evenly padded with white-space$
my $text = q:to/END/;
                                 
 @@@@@              @@           
 @    @              @     @@@   
 @    @              @    @@     
 @    @  @@@   @ @@  @    @@     
 @@@@@  @   @  @@  @ @    @@@@@  
 @      @@@@@  @     @    @@  @@ 
 @      @      @     @    @@  @@ 
 @       @@@   @     @@    @@@@  
                                 
END

say '' for ^5;
for $text.lines -> $_ is copy {
    my @chars = |｢-+ ., ;: '"｣.comb.pick(*) xx *;
    s:g [' '] = @chars.shift;
    print "                              $_  ";
    s:g [('@'+)(.)] = @chars.shift ~ $0;
    .say;
}
say '' for ^5;
Output:




                              ";,' :-+  . ,. ; -:+"',';-. : " +   ";,' :-+  . ,. ; -:+"',';-. : " + 
                              :@@@@@  ,'+".-; ;-+,@@"'  :.  ;. "  :'@@@@@ ,'+".-; ;-+,,@@'  :.  ;. "
                              "@-.  @ ';,+:- +:  ,;@'". +@@@, "-  " @.  .@';,+:- +:  ,;:@". +;@@@ "-
                              '@,- ;@ "+: .+ -',:" @; . @@; -" ,  ':@- ;'@"+: .+ -',:" .@ . +@@ -" ,
                              ;@ +, @"-@@@' :@.@@  @-,:.@@+ ;'":  ; @+, .@-'@@@ : @;@@  @,:.+@@ ;'":
                               @@@@@+-@':.@, @@" @;@ +":@@@@@',    ;@@@@@--@:. @ .@@ :@ @+": @@@@@, 
                               @;-+, .@@@@@ :@"'+' @"-,:@@; @@.    +@-+, .,@@@@@::@'+'  @-,: @@ "@@ 
                              :@ . "- @,;+'; @" .-'@ +:,@@ ;@@'+  :-@. "- ,@;+'; "@ .-' @+:, @@;:@@+
                              +@'"., ; @@@ -:@;'  "@@-+.:@@@@,    +:@"., ; "@@@-:;@'  ".@@+.: @@@@  
                               ;.:+"-,'  +:'; -,"  .+:"  ;-.,' .   ;.:+"-,'  +:'; -,"  .+:"  ;-.,' .

Raven

[
" #####    ####   #     #  ####  #    #"
" #    #  #    #   #   #   #     ##   #"
" #    #  #    #   #   #   ###   # #  #"
" #####   ######    # #    ###   #  # #"
" #  #    #    #    # #    #     #   ##"
" #   #   #    #     #     ####  #    #"
]  as $str

"/" as $r1
">" as $r2

#$str each "%s\n" print

$str each as $line
  $line r/#/@@@/g   r/ /X/g  r/X/   /g   r/@ /@!/g   r/@$/@!/g as $l1
  $l1   "@" split $r1 join "!" split $r2 join  print "\n" print
Output:
   ///////////////>           ////////////>        ///>              ///>     ////////////>     ///>           ///>
   ///>           ///>     ///>           ///>        ///>        ///>        ///>              //////>        ///>
   ///>           ///>     ///>           ///>        ///>        ///>        /////////>        ///>  ///>     ///>
   ///////////////>        //////////////////>           ///>  ///>           /////////>        ///>     ///>  ///>
   ///>     ///>           ///>           ///>           ///>  ///>           ///>              ///>        //////>
   ///>        ///>        ///>           ///>              ///>              ////////////>     ///>           ///>

REXX

block characters

The REXX program works in   ASCII   or   EBCDIC.

It's astonishing how much time I wasted spent on this program.
Most of the time was spent on writing comments, but the code was so easy to read, so the comments were elided.   ☺

This REXX has been used as part of a test suite for some REXX interpreters to stress test their syntax parser. 

/*REXX program that displays a  "REXX"  3D  "ASCII art"  as a  logo.  */
signal .                  /* Uses left-hand shadows, slightly raised view.
0=5~2?A?2?A?
@)E)3@)B)1)2)8()2)1)2)8()2)
@]~")2@]0`)0@)%)6{)%)0@)%)6{)%)
#E)1#A@0}2)4;2(1}2)4;2(
#3??3@0#2??@1}2)2;2(3}2)2;2(
#2@5@)@2@0#2@A}2)0;2(5}2)0;2(
#2@?"@)@2@0#2@?7}2){2(7}2){2(
#2@6)@2@0#2@3)7}2)(2(9}2)(2(
#2@??@2@0#2@?_)7}5(B}5(
#F@0#8@8}3(D}3(
#3%3?(1#3?_@7;3)C;3)
#2@0}2)5#2@C;5)A;5)
#2@1}2)4#2@B;2()2)8;2()2)
#2@2}2)3#2@?"4;2(}2)6;2(}2)
#2@3}2)2#2@5)2;2(1}2)4;2(1}2)
#2@4}2)1#2@?%)0;2(3}2)2;2(3}2)
0]@2@5}2)1]@A@0)[2(5}2)1)[2(5}2)
1)@%@6}%)1)@`@1V%(7}%)1V%(7}%)
*/;.:a=sigL+1;signal ..;..:u='_';do j=a to sigl-1
_=sourceline(j);_=_('(',"/");_=_('[',"//");_=_('{',"///")
_=_(';',"////");_=_(')',"\");_=_(']',"\\");_=_('}',"\\\");_=_('"',"__")
_=_('%',"___");_=_('?',left('',4,u));_=_('`',left('',11,u));_=_('~',left('',
,13,u));_=_('=',left('',16,u));_=_('#','|\\|');_=translate(_,"|"u,'@"')
do k=0 for 16;x=d2x(k,1);_=_(x,left('',k+1));end;say ' '_;end;exit;_:return,
changestr(arg(1),_,arg(2))

Some older REXXes don't have a   changestr   BIF, so one is included here   ──►   CHANGESTR.REX.

output   when using the internal default input:

output 

  ________________      _____________   ____           ____   ____           ____
 |\               \    |\            \  \   \         /\   \  \   \         /\   \
 |\\_______________\   |\\ ___________\ |\___\       ///\___\ |\___\       ///\___\
 |\\|               \  |\\|           | \\\   \     ////   /  \\\   \     ////   /
 |\\|    ________    | |\\|   ________|  \\\   \   ////   /    \\\   \   ////   /
 |\\|   |      |\|   | |\\|   |           \\\   \ ////   /      \\\   \ ////   /
 |\\|   |______|\|   | |\\|   |____        \\\   \///   /        \\\   \///   /
 |\\|   |       \|   | |\\|   |    \        \\\   \/   /          \\\   \/   /
 |\\|   |________|   | |\\|   |_____\        \\\      /            \\\      /
 |\\|                | |\\|         |         \\\    /              \\\    /
 |\\|    ___    ____/  |\\|    _____|        ////    \             ////    \
 |\\|   | \\\   \      |\\|   |             ////      \           ////      \
 |\\|   |  \\\   \     |\\|   |            ////   /\   \         ////   /\   \
 |\\|   |   \\\   \    |\\|   |______     ////   /\\\   \       ////   /\\\   \
 |\\|   |    \\\   \   |\\|   |      \   ////   /  \\\   \     ////   /  \\\   \
 |\\|   |     \\\   \  |\\|   |_______\ ////   /    \\\   \   ////   /    \\\   \
  \\|   |      \\\   \  \\|           | \//   /      \\\   \  \//   /      \\\   \
   \|___|       \\\___\  \|___________|  V___/        \\\___\  V___/        \\\___\

Unobfuscated

Translation of: NetRexx
Works with: ooRexx
Works with: Regina
/* Rexx */

drop !top !bot
x = 0
x = x + 1; txt.0 = x; txt.x = '   *****'
x = x + 1; txt.0 = x; txt.x = '   *    *'
x = x + 1; txt.0 = x; txt.x = '   *    * ***** *   * *   *'
x = x + 1; txt.0 = x; txt.x = '   *****  *      * *   * *'
x = x + 1; txt.0 = x; txt.x = '   *  *   ***     *     *'
x = x + 1; txt.0 = x; txt.x = '   *   *  *      * *   * *'
x = x + 1; txt.0 = x; txt.x = '   *    * ***** *   * *   *'
x = x + 1; txt.0 = x; txt.x = ''

call Banner3D isTrue()
do ll = 1 to txt.0
  say txt.ll.!top
  say txt.ll.!bot
  end ll

return
exit

Banner3D:
procedure expose txt.
  drop !top !bot
  parse arg slope .

  select
    when slope = isTrue() then nop
    when slope = isFalse() then nop
    otherwise do
      if slope = '' then slope = isFalse()
                    else slope = isTrue()
      end
    end

  do ll = 1 to txt.0
    txt.ll.!top = txt.ll
    txt.ll.!bot = txt.ll
    txt.ll.!top = changestr(' ', txt.ll.!top, '   ')
    txt.ll.!bot = changestr(' ', txt.ll.!bot, '   ')
    txt.ll.!top = changestr('*', txt.ll.!top, '///')
    txt.ll.!bot = changestr('*', txt.ll.!bot, '\\\')
    txt.ll.!top = txt.ll.!top || ' '
    txt.ll.!bot = txt.ll.!bot || ' '
    txt.ll.!top = changestr('/ ', txt.ll.!top, '/\')
    txt.ll.!bot = changestr('\ ', txt.ll.!bot, '\/')
    end ll

  if slope then do
    do li = txt.0 to 1 by -1
      ll = txt.0 - li + 1
      txt.ll.!top = insert('', txt.ll.!top, 1, li - 1, ' ')
      txt.ll.!bot = insert('', txt.ll.!bot, 1, li - 1, ' ')
      end li
    end

  return
exit

isTrue:
procedure
  return 1 == 1

isFalse:
procedure
  return \isTrue()
Output:
                ///////////////\
                \\\\\\\\\\\\\\\/
               ///\           ///\
               \\\/           \\\/
              ///\           ///\  ///////////////\  ///\        ///\  ///\        ///\
              \\\/           \\\/  \\\\\\\\\\\\\\\/  \\\/        \\\/  \\\/        \\\/
             ///////////////\     ///\                 ///\  ///\        ///\  ///\
             \\\\\\\\\\\\\\\/     \\\/                 \\\/  \\\/        \\\/  \\\/
            ///\     ///\        /////////\              ///\              ///\
            \\\/     \\\/        \\\\\\\\\/              \\\/              \\\/
           ///\        ///\     ///\                 ///\  ///\        ///\  ///\
           \\\/        \\\/     \\\/                 \\\/  \\\/        \\\/  \\\/
          ///\           ///\  ///////////////\  ///\        ///\  ///\        ///\
          \\\/           \\\/  \\\\\\\\\\\\\\\/  \\\/        \\\/  \\\/        \\\/

simpler, shorter

This is a version of the above REXX program (with a minor bug fixed),
the input text has additional spacing between the   letters   for better readability,
the letter   E   (in the input text) was shortened,
the output doesn't have extraneous leading blanks,
the output doesn't have trailing blanks,
the input text can be any consistent non-blank character except the forward slash   (/)   or backward slash  (\). 

/*REXX pgm draws a "3D" image of text representation;  any character except  /  and  \  */
#=7;                       @.1 =  '@@@@                        '
                           @.2 =  '@   @                       '
                           @.3 =  '@   @   @@@@  @   @  @   @  '
                           @.4 =  '@@@@    @      @ @    @ @   '
                           @.5 =  '@  @    @@@     @      @    '
                           @.6 =  '@   @   @      @ @    @ @   '
                           @.7 =  '@    @  @@@@  @   @  @   @  '
  do j=1  for #;  x=left(strip(@.j),1)           /* [↓]  display the (above) text lines.*/
  $.1 = changestr( " " ,   @.j,   '   '   )       ;      $.2 = $.1
  $.1 = changestr(  x  ,   $.1,   '///'   )" "
  $.2 = changestr(  x  ,   $.2,   '\\\'   )" "
  $.1 = changestr( "/ ",   $.1,   '/\'    )
  $.2 = changestr( "\ ",   $.2,   '\/'    )
       do k=1  for 2;  say strip(left('',#-j)$.k,"T")   /*the LEFT BIF does indentation.*/
       end  /*k*/                                /* [↑]  display a line  and its shadow.*/
  end       /*j*/                                /*stick a fork in it,  we're all done. */
output   when using the internal default input:
      ////////////\
      \\\\\\\\\\\\/
     ///\        ///\
     \\\/        \\\/
    ///\        ///\        ////////////\     ///\        ///\     ///\        ///\
    \\\/        \\\/        \\\\\\\\\\\\/     \\\/        \\\/     \\\/        \\\/
   ////////////\           ///\                 ///\  ///\           ///\  ///\
   \\\\\\\\\\\\/           \\\/                 \\\/  \\\/           \\\/  \\\/
  ///\     ///\           /////////\              ///\                 ///\
  \\\/     \\\/           \\\\\\\\\/              \\\/                 \\\/
 ///\        ///\        ///\                 ///\  ///\           ///\  ///\
 \\\/        \\\/        \\\/                 \\\/  \\\/           \\\/  \\\/
///\           ///\     ////////////\     ///\        ///\     ///\        ///\
\\\/           \\\/     \\\\\\\\\\\\/     \\\/        \\\/     \\\/        \\\/

Ruby

text = <<EOS
####        #
#   #       #
#   #       #
####  #  #  ###  #   #
# #   #  #  #  #  # #
#  #  #  #  #  #   #
#   #  ###  ###   #
                 #
                #
EOS

def banner3D_1(text, shift=-1)
  txt = text.each_line.map{|line| line.gsub('#','__/').gsub(' ','   ')}
  offset = Array.new(txt.size){|i| " " * shift.abs * i}
  offset.reverse! if shift < 0
  puts offset.zip(txt).map(&:join)
end
banner3D_1(text)

puts
# Other display:
def banner3D_2(text, shift=-2)
  txt = text.each_line.map{|line| line.chomp + ' '}
  offset = txt.each_index.map{|i| " " * shift.abs * i}
  offset.reverse! if shift < 0
  txt.each_with_index do |line,i|
    line2 = offset[i] + line.gsub(' ','   ').gsub('#','///').gsub('/ ','/\\')
    puts line2, line2.tr('/\\\\','\\\\/')
  end
end
banner3D_2(text)

puts
# Another display:
def banner3D_3(text)
  txt = text.each_line.map(&:rstrip)
  offset = [*0...txt.size].reverse
  area = Hash.new(' ')
  box = [%w(/ / / \\), %w(\\ \\ \\ /)]
  txt.each_with_index do |line,i|
    line.each_char.with_index do |c,j|
      next if c==' '
      x = offset[i] + 2*j
      box[0].each_with_index{|c,k| area[[x+k,i  ]] = c}
      box[1].each_with_index{|c,k| area[[x+k,i+1]] = c}
    end
  end
  (xmin, xmax), (ymin, ymax) = area.keys.transpose.map(&:minmax)
  puts (ymin..ymax).map{|y| (xmin..xmax).map{|x| area[[x,y]]}.join}
end

banner3D_3 <<EOS
####         #
#   #        #
#   #        #
#   #        #
####   #  #  ####  #     #
# #    #  #  #   #  #   #
#  #   #  #  #   #   # #
#   #  #  #  #   #    #
#    #  ###  ####    #
                    #
                   #
EOS
Output:
        __/__/__/__/                        __/
       __/         __/                     __/
      __/         __/                     __/
     __/__/__/__/      __/      __/      __/__/__/      __/         __/
    __/   __/         __/      __/      __/      __/      __/   __/
   __/      __/      __/      __/      __/      __/         __/
  __/         __/      __/__/__/      __/__/__/         __/
                                                    __/
                                                __/

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

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

Another version: like a 3D solid. 

enc = "9 8u18 2u1\n8 1s 6u1 b16 1s sb\n6 2 s1b4u1s sb13 3 s1\n5 3 s3 3s 11 3 s1\n4 2 s1us3u1su2s 2u4 2u3 2 s1us3u4 2u6 2u1\n4 1s 6u1sbubs2 s1b 2 s1b2 1s 6u1 b2 1susb3 2 s1b\n2 2 s1b2 3u1bs2 8 s1b4u1s s4b 3 s1\n 3 s3b 2 9 s3 3s 3 b2s 1s\n 3s 3 b1 2 s2us4 s1us2u2us1 s3 3 b1s s\nsu2s 2 4 b6u2s 1s7u1sbubs6 1bub2 1s\nbubs6 1bubs2 1b5u1bs  b7u1bs8 3 s1\n42 2u2s 1s\n41 1s3u1s s\n41 1b3u1bs\n"
def decode(str)
  str.split(/(\d+)(\D+)/).each_slice(3).map{|_,n,s| s * n.to_i}.join.tr('sub','/_\\')
end
puts decode(enc)
Output:
         ________                  __
        / ______ \                / /\
       / /\____/ /\              / / /
      / / /   / / /             / / /
     / /_/___/_/ / __    __    / /_/___    __      __
    / ______/\_\/ / /\  / /\  / ______ \  /_/\    / /\
   / /\  ___\/   / / / / / / / /\____/ /\ \ \ \  / / /
  / / /\ \ \    / / / / / / / / /   / / /  \ \ \/ / /
 / / /  \ \ \  / /_/_/ / / / /_/___/_/ /    \ \ \/ /
/_/ /    \ \ \ \______/ / /_______/\_\/      \_\  /
\_\/      \_\/  \_____\/  \_______\/         / / /
                                          __/ / /
                                         /___/ /
                                         \___\/

Rust

pub fn char_from_id(id: u8) -> char {
    [' ', '#', '/', '_', 'L', '|', '\n'][id as usize]
}

const ID_BITS: u8 = 3;

pub fn decode(code: &[u8]) -> String {
    let mut ret = String::new();
    let mut carry = 0;
    let mut carry_bits = 0;
    for &b in code {
        let mut bit_pos = ID_BITS - carry_bits;
        let mut cur = b >> bit_pos;
        let mask = (1 << bit_pos) - 1;
        let id = carry | (b & mask) << carry_bits;
        ret.push(char_from_id(id));
        while bit_pos + ID_BITS < 8 {
            ret.push(char_from_id(cur & ((1 << ID_BITS) - 1)));
            cur >>= ID_BITS;
            bit_pos += ID_BITS;
        }
        carry = cur;
        carry_bits = 8 - bit_pos;
    }
    ret
}

fn main() {
    let code = [
        72, 146, 36, 0, 0, 0, 0, 0, 0, 0, 128, 196, 74, 182, 41, 1, 0, 0, 0, 0, 0, 0, 160, 196, 77, 0,
        52, 1, 18, 0, 9, 144, 36, 9, 146, 36, 113, 147, 36, 9, 160, 4, 80, 130, 100, 155, 160, 41, 145,
        155, 108, 74, 128, 38, 64, 19, 41, 73, 2, 160, 137, 155, 0, 84, 130, 38, 64, 19, 112, 155, 18,
        160, 137, 155, 0, 160, 18, 42, 73, 18, 36, 73, 2, 128, 74, 76, 1, 0, 40, 128, 219, 38, 104, 219,
        4, 0, 160, 0
    ];

    println!("{}", decode(&code));
}
Output:
 #######                     ##
/##___/##                   /##
|##   |##  ##   ##  ###### ######
|#######  /##  /## ##___/ /_/##/
|##__/##  |##  |##//#####   |##
|##  L/## |##  |## L___/##  |##
|##   L/##L/###### ######   L/##
L/     L/  L____/ /____/     L/

Scala

Library: Scala

Java style

def ASCII3D = {

val name = """
               *
   **  **  *   *    *
  *   *   * *  *   * *
  *   *   * *  *   * *
   *  *   ***  *   ***
    * *   * *  *   * *
    * *   * *  *   * *
  **   ** *  * *** * *
                     *
                      *
  """

// Create Array

def getMaxSize(s: String): (Int, Int) = {
  var width = 0
  var height = 0

  val nameArray = s.split("\n")
  height = nameArray.size
  nameArray foreach { i => width = (i.size max width) }

  (width, height)
}

val size = getMaxSize(name)
var arr = Array.fill(size._2 + 1, (size._1 * 3) + (size._2 + 1))(' ')

//
// Map astrisk to 3D cube
//
val cubeTop = """///\""" //"
val cubeBottom = """\\\/""" //"

val nameArray = name.split("\n")

for (j <- (0 until nameArray.size)) {
  for (i <- (0 until nameArray(j).size)) {
    if (nameArray(j)(i) == '*') {
      val indent = nameArray.size - j
      arr(j) = arr(j) patch ((i * 3 + indent), cubeTop, cubeTop.size)
      arr(j + 1) = arr(j + 1) patch ((i * 3 + indent), cubeBottom, cubeBottom.size)
    }
  }
}

//
// Map Array to String
//
var name3D = ""

for (j <- (0 until arr.size)) {
  for (i <- (0 until arr(j).size)) { name3D += arr(j)(i) }
  name3D += "\n"
    }
    name3D
  }

  println(ASCII3D)

Idiomatic

Cleaner code. 

import scala.collection.mutable.ArraySeq

object Ascii3D extends App {
  def ASCII3D = {
    val picture = """               *
   **  **  *   *    *
  *   *   * *  *   * *
  *   *   * *  *   * *
   *  *   ***  *   ***
    * *   * *  *   * *
    * *   * *  *   * *
  **   ** *  * *** * *
                     *
                      *""".split("\n")

    var arr = {
      val (x, y) = // Get maximal format and create a 2-D array with it.
        (picture.foldLeft(0)((i, s) => i max s.length), picture.size)
      ArraySeq.fill(y + 1, (x * 3) + (y + 1))(' ')
    }

    //
    // Map asterisks to 3D cube
    //
    val (cubeTop, cubeBottom) = ("""///\""", """\\\/""") // "

    for {
      y <- 0 until picture.size
      x <- 0 until picture(y).size
      if picture(y)(x) == '*'
      indent = picture.size - y
    } {
      arr(y) = arr(y) patch ((x * 3 + indent), cubeTop, cubeTop.size)
      arr(y + 1) = arr(y + 1) patch ((x * 3 + indent), cubeBottom, cubeBottom.size)
    }
    // Transform array to String
    arr.map(_.mkString).mkString("\n")
  }

  println(ASCII3D)
}
Output:
                                                       ///\
                  //////\     //////\     ///\        ///\/          ///\
              ///\\\\\\\/ ///\\\\\\\/ ///\\\///\     ///\/       ///\\\///\
             ///\/       ///\/       ///\/ ///\/    ///\/       ///\/ ///\/
             \\///\     ///\/       /////////\/    ///\/       /////////\/
               \\///\  ///\/       ///\\\///\/    ///\/       ///\\\///\/
                ///\/ ///\/       ///\/ ///\/    ///\/       ///\/ ///\/
         //////\\\\/  \\//////\  ///\/  \\///\  /////////\  ///\/ ///\/
         \\\\\\/        \\\\\\/  \\\/     \\\/  \\\\\\\\\/  \\\/ ///\/
                                                                 \\///\
                                                                   \\\/

Seed7

$include "seed7_05.s7i";

const array string: name is [] (
    " ***                  * ***** ",
    "*                     *     * ",
    "*      ***   ***   ****     * ",
    "*     *   * *   * *   *    *  ",
    " ***  *   * *   * *   *    *  ",
    "    * ***** ***** *   *   *   ",
    "    * *     *     *   *   *   ",
    "    * *     *     *   *  *    ",
    " ***   ***   ***   ****  *    ");

const proc: main is func
  local
    var integer: index is 0;
    var string: help is "";
    var string: line is "";
    var string: previousLine is "";
    var integer: pos is 0;
  begin
    for index range 1 to length(name) do
      help := replace(name[index], " ", "   ");
      line := "" lpad length(name) - index <&
              replace(replace(help, "*", "///"), "/ ", "/\\");
      if previousLine = "" then
        writeln(line);
      else
        for pos range 1 to length(line) do
          if line[pos] <> ' ' then
            write(line[pos]);
          else
            write(previousLine[pos]);
          end if;
        end for;
        writeln;
      end if;
      previousLine := "" lpad length(name) - index <&
                      replace(replace(help, "*", "\\\\\\"), "\\ ", "\\/");
    end for;
    writeln(previousLine);
  end func;
Output:
           /////////\                                                     ///\  ///////////////\  
       ///\\\\\\\\\\/                                                    ///\/  \\\\\\\\\\\///\/ 
      ///\/                /////////\        /////////\        ////////////\/             ///\/ 
     ///\/             ///\\\\\\\\\///\  ///\\\\\\\\\///\  ///\\\\\\\\\///\/          ///\\\\/ 
     \\/////////\     ///\/       ///\/ ///\/       ///\/ ///\/       ///\/          ///\/    
       \\\\\\\\///\  ///////////////\/ ///////////////\/ ///\/       ///\/       ///\\\\/    
              ///\/ ///\\\\\\\\\\\\\/ ///\\\\\\\\\\\\\/ ///\/       ///\/       ///\/       
             ///\/ ///\/             ///\/             ///\/       ///\/    ///\\\\/       
   /////////\\\\/  \\/////////\      \\/////////\      \\////////////\/    ///\/          
   \\\\\\\\\/        \\\\\\\\\/        \\\\\\\\\/        \\\\\\\\\\\\/     \\\/

Sidef

Translation of: Ruby
var text = <<'EOT';

     ***
    *     *     *        **
    *           *       *
    *     *     *  ***  **
     ***  *  **** *   * *
        * * *   * ***** *
        * * *   * *     *
        * * *   * *     *
     ***  *  ****  ***  *
EOT

func banner3D(text, shift=-1) {
    var txt = text.lines.map{|line| line.gsub('*','__/').gsub(' ','   ')};
    var offset = txt.len.of {|i| " " * (shift.abs * i)};
    shift < 0 && offset.reverse!;
    (offset »+« txt).join("\n");
};

say banner3D(text);

          
                        __/__/__/
                    __/               __/               __/                        __/__/
                   __/                                 __/                     __/
                  __/               __/               __/      __/__/__/      __/__/
                    __/__/__/      __/      __/__/__/__/   __/         __/   __/
                            __/   __/   __/         __/   __/__/__/__/__/   __/
                           __/   __/   __/         __/   __/               __/
                          __/   __/   __/         __/   __/               __/
                __/__/__/      __/      __/__/__/__/      __/__/__/      __/

SQL

select           ' SSS\ ' as s, ' QQQ\  ' as q, 'L\   ' as l  from dual
union all select 'S   \|',      'Q   Q\ ',      'L |  '       from dual
union all select '\SSS  ',      'Q   Q |',      'L |  '       from dual
union all select ' \  S\',      'Q Q Q |',      'L |  '       from dual
union all select ' SSS |',      '\QQQ\\|',      'LLLL\'       from dual
union all select ' \__\/',      ' \_Q_/ ',      '\___\'       from dual
union all select '      ',      '   \\  ',      '     '       from dual;

This works in Oracle. For other databases, try it without "from dual".

Output:
S      Q       L
------ ------- -----
 SSS\   QQQ\   L\
S   \| Q   Q\  L |
\SSS   Q   Q | L |
 \  S\ Q Q Q | L |
 SSS | \QQQ\\| LLLL\
 \__\/  \_Q_/  \___\
          \\

7 rows selected.

Tcl

package require Tcl 8.5

proc mergeLine {upper lower} {
    foreach u [split $upper ""] l [split $lower ""] {
	lappend result [expr {$l in {" " ""} ? $u : $l}]
    }
    return [join $result ""]
}
proc printLines lines {
    set n [llength $lines]
    foreach line $lines {
	set indent [string repeat " " $n]
	lappend upper $indent[string map {"/ " "/\\"} [
		string map {" " "   " "*" "///"} "$line "]]
	lappend lower $indent[string map {"\\ " "\\/"} [
		string map {" " "   " "*" "\\\\\\"} "$line "]]
	incr n -1
    }
    # Now do some line merging to strengthen the visual effect
    set p [string repeat " " [string length [lindex $upper 0]]]
    foreach u $upper l $lower {
	puts [mergeLine $p $u]
	set p $l
    }
    puts $p
}

set lines {
    {*****   *}
    {  *     *}
    {  * *** *}
    {  * *   *}
    {  * *   *}
    {  * *** *}
}
printLines $lines
Output:
      ///////////////\        ///\  
      \\\\\///\\\\\\\/       ///\/  
          ///\/ /////////\  ///\/  
         ///\/ ///\\\\\\\/ ///\/  
        ///\/ ///\/       ///\/  
       ///\/ /////////\  ///\/  
       \\\/  \\\\\\\\\/  \\\/

UNIX Shell

Works with: Bash version 4
#!/usr/bin/env bash
mapfile -t name <<EOF
Aimhacks
EOF

main() {
  banner3d_1 "${name[@]}"
  echo
  banner3d_2 "${name[@]}"
  echo
  banner3d_3 "${name[@]}"
}

space() {
  local -i n i
  (( n=$1 )) || n=1
  if (( n < 1 )); then n=1; fi
  for ((i=0; i<n; ++i)); do
    printf ' '
  done
  printf '\n'
}

banner3d_1() {
  local txt i
  mapfile -t txt < <(printf '%s\n' "$@" | sed -e 's,#,__/,g' -e 's/ /   /g')
  for i in "${!txt[@]}"; do
    printf '%s%s\n' "$(space $(( ${#txt[@]} - i )))" "${txt[i]}"
  done
}

banner3d_2() {
  local txt i line line2
  mapfile -t txt < <(printf '%s \n' "$@")
  for i in "${!txt[@]}"; do
    line=${txt[i]}
    line2=$(printf '%s%s' "$(space $(( 2 * (${#txt[@]} - i) )))" "$(sed -e 's, ,   ,g' -e 's,#,///,g' -e 's,/ ,/\\,g' <<<"$line")")
    printf '%s\n%s\n' "$line2" "$(tr '/\\' '\\/' <<<"$line2")"
  done
}

banner3d_3() {
  # hard-coded fancy one
  cat <<'EOF'
  ______________      ___________    ___________   ____       ____␣
 /             /\    /          |\  /|          \ |\   \     |\   \
/_____________/  /| /___________||  ||___________\| \___\    |  \___\␣
|             \ / |/             \  /             | |   |    |  |   |
|   ________   |  |   ________   |  |    _________| |   |    |  |   |
|   |  |___|   |  |   | |____|   |  |   |_______  | |   |____|  |   |
|   | /    |   | /|   | /    |   |  |   |       \ | |   |     \ |   |
|   |/_____|   |/ |   |/_____|   |  |   |________\| |   |______\|   |
|              / /|              |  |             \ |               |
|    ______   \ / |    _______   |  \_________    | |    ________   |
|   |  |___|   |  |   | |    |   |  _________/|   | |   |    |  |   |
|   | /    |   |  |   | |    |   | |         ||   | |   |    |  |   |
|   |/_____|   | /|   | |    |   | |_________|/   | |   |     \ |   |
|              |/ |   | |    |   | |              | |   |      \|   |
|_____________/   |___|/     |___| |_____________/ \|___|       |___|
EOF
}

main "$@"
Output:
        __/__/__/                                       __/
       __/      __/                                    __/
      __/      __/                                    __/
     __/__/__/            __/__/         __/__/__/   __/__/__/
    __/      __/               __/   __/            __/      __/
   __/      __/      __/__/__/__/      __/__/      __/      __/
  __/      __/   __/      __/__/            __/   __/      __/
 __/__/__/         __/__/   __/   __/__/__/      __/      __/

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

  ______________      ___________    ___________   ____       ____␣
 /             /\    /          |\  /|          \ |\   \     |\   \
/_____________/  /| /___________||  ||___________\| \___\    |  \___\␣
|             \ / |/             \  /             | |   |    |  |   |
|   ________   |  |   ________   |  |    _________| |   |    |  |   |
|   |  |___|   |  |   | |____|   |  |   |_______  | |   |____|  |   |
|   | /    |   | /|   | /    |   |  |   |       \ | |   |     \ |   |
|   |/_____|   |/ |   |/_____|   |  |   |________\| |   |______\|   |
|              / /|              |  |             \ |               |
|    ______   \ / |    _______   |  \_________    | |    ________   |
|   |  |___|   |  |   | |    |   |  _________/|   | |   |    |  |   |
|   | /    |   |  |   | |    |   | |         ||   | |   |    |  |   |
|   |/_____|   | /|   | |    |   | |_________|/   | |   |     \ |   |
|              |/ |   | |    |   | |              | |   |      \|   |
|_____________/   |___|/     |___| |_____________/ \|___|       |___|

Visual Basic .NET

Translation of: C#
Module Module1

    Sub Main()
        Console.WriteLine(" ___      ___ ___  ________  ___  ___  ________  ___               ________  ________  ________  ___  ________           ________   _______  _________   
|\  \    /  /|\  \|\   ____\|\  \|\  \|\   __  \|\  \             |\   __  \|\   __  \|\   ____\|\  \|\   ____\         |\   ___  \|\  ___ \|\___   ___\ 
\ \  \  /  / | \  \ \  \___|\ \  \\\  \ \  \|\  \ \  \            \ \  \|\ /\ \  \|\  \ \  \___|\ \  \ \  \___|         \ \  \\ \  \ \   __/\|___ \  \_| 
 \ \  \/  / / \ \  \ \_____  \ \  \\\  \ \   __  \ \  \            \ \   __  \ \   __  \ \_____  \ \  \ \  \             \ \  \\ \  \ \  \_|/__  \ \  \  
  \ \    / /   \ \  \|____|\  \ \  \\\  \ \  \ \  \ \  \____        \ \  \|\  \ \  \ \  \|____|\  \ \  \ \  \____       __\ \  \\ \  \ \  \_|\ \  \ \  \ 
   \ \__/ /     \ \__\____\_\  \ \_______\ \__\ \__\ \_______\       \ \_______\ \__\ \__\____\_\  \ \__\ \_______\    |\__\ \__\\ \__\ \_______\  \ \__\
    \|__|/       \|__|\_________\|_______|\|__|\|__|\|_______|        \|_______|\|__|\|__|\_________\|__|\|_______|    \|__|\|__| \|__|\|_______|   \|__|
                     \|_________|                                                        \|_________|                                                    
                                                                                                                                                         
                                                                                                                                                         
")
    End Sub

End Module
Output:
 ___      ___ ___  ________  ___  ___  ________  ___               ________  ________  ________  ___  ________           ________   _______  _________   
|\  \    /  /|\  \|\   ____\|\  \|\  \|\   __  \|\  \             |\   __  \|\   __  \|\   ____\|\  \|\   ____\         |\   ___  \|\  ___ \|\___   ___\ 
\ \  \  /  / | \  \ \  \___|\ \  \\\  \ \  \|\  \ \  \            \ \  \|\ /\ \  \|\  \ \  \___|\ \  \ \  \___|         \ \  \\ \  \ \   __/\|___ \  \_| 
 \ \  \/  / / \ \  \ \_____  \ \  \\\  \ \   __  \ \  \            \ \   __  \ \   __  \ \_____  \ \  \ \  \             \ \  \\ \  \ \  \_|/__  \ \  \  
  \ \    / /   \ \  \|____|\  \ \  \\\  \ \  \ \  \ \  \____        \ \  \|\  \ \  \ \  \|____|\  \ \  \ \  \____       __\ \  \\ \  \ \  \_|\ \  \ \  \ 
   \ \__/ /     \ \__\____\_\  \ \_______\ \__\ \__\ \_______\       \ \_______\ \__\ \__\____\_\  \ \__\ \_______\    |\__\ \__\\ \__\ \_______\  \ \__\
    \|__|/       \|__|\_________\|_______|\|__|\|__|\|_______|        \|_______|\|__|\|__|\_________\|__|\|_______|    \|__|\|__| \|__|\|_______|   \|__|
                     \|_________|                                                        \|_________|

Wren

This uses the 3D ASCII letter font here. 

var w = """
  ____    ____    ____   
 |\   \  |\   \  |\   \  
 | \   \ | \   \ | \   \ 
 \  \   \\ /    \\ /   /|
  \  \   \V      \V   / |
   \  \      /\      /  /
    \  \____/  \____/  / 
     \ |    | /|    | /  
      \|____|/ |____|/   
""".split("\n")      

var r = """
  _______    ____  
 |\__    \  /    \ 
 || |\    \/   ___\
 \|_| \       /|__|
    \  \     //    
     \  \    \     
      \  \____\    
       \ |    |    
        \|____|    
""".split("\n")

var e = """
    ___________      
   /   _____   \     
  /   /_____\   \    
 |\       _____/|    
 | \     /|____|/    
 \  \    \/_______/\ 
  \  \_____________/|
   \ |            | |
    \|____________|/ 
""".split("\n")

var n = """
  _____  _______       
 |\__  \/       \      
 || |\      __   \    
 \|_| \    /| \   \   
    \  \   \/\ \   \  
     \  \   \ \ \   \ 
      \  \___\ \ \___\
       \ |   |  \|   |
        \|___|   |___|
""".split("\n")

for (i in 0..8) {
   System.print("%(w[i]) %(r[i]) %(e[i]) %(n[i])")
}
Output:
  ____    ____    ____      _______    ____       ___________         _____  _______       
 |\   \  |\   \  |\   \    |\__    \  /    \     /   _____   \       |\__  \/       \      
 | \   \ | \   \ | \   \   || |\    \/   ___\   /   /_____\   \      || |\      __   \    
 \  \   \\ /    \\ /   /|  \|_| \       /|__|  |\       _____/|      \|_| \    /| \   \   
  \  \   \V      \V   / |     \  \     //      | \     /|____|/         \  \   \/\ \   \  
   \  \      /\      /  /      \  \    \       \  \    \/_______/\       \  \   \ \ \   \ 
    \  \____/  \____/  /        \  \____\       \  \_____________/|       \  \___\ \ \___\
     \ |    | /|    | /          \ |    |        \ |            | |        \ |   |  \|   |
      \|____|/ |____|/            \|____|         \|____________|/          \|___|   |___|

XPL0

Here's XPL0's "cheap hack." (Hats off to D!) 

include c:\cxpl\codes;

proc    DrawBlock(X, Y);
int     X, Y;
[Cursor(X+1, Y);   Text(0, "///\");
 Cursor(X, Y+1);   Text(0,"///  \");
 Cursor(X, Y+2);   Text(0,"\\\  /");
 Cursor(X+1, Y+3); Text(0, "\\\/");
];

int     Data, D, X, Y;
[ChOut(0, $C);     \form feed, clears screen
Data:= [%1000100011110000100000001110,
        %1000100010001000100000010001,
        %0101000010001000100000010011,
        %0010000011110000100000010101,
        %0101000010000000100000011001,
        %1000100010000000100000010001,
        %1000100010000000111110001110];
for Y:= 0 to 6 do
        [D:= Data(Y);
        for X:= 0 to 27 do
                [if D&1<<27 then DrawBlock(X*2+(6-Y)*2, Y*2);
                D:= D<<1;
                ];
        ];
]
Output:
             ///\    ///\    /////////\      ///\            ///////\
            ///  \  ///  \  /////////  \    ///  \          ///////  \
           ///\  / ///\  / ///\\\\\///\/   ///\  /       ///\\\\\///\/
          ///  \/ ///  \/ ///  \\\///  \  ///  \/       ///  \\\///  \
          \///\///\\\  / ///\  / ///\  / ///\  /       ///\  /////\  /
          /// ///  \\\/ ///  \/ ///  \/ ///  \/       ///  \/////  \/
          \///\\\  /   /////////\\\  / ///\  /       ///\///\///\  /
          ///  \\\/   /////////  \\\/ ///  \/       /// /// ///  \/
       ///\///\/     ///\\\\\\\  /   ///\  /       /////\\\///\  /
      /// ///  \    ///  \\\\\\\/   ///  \/       /////  \///  \/
   ///\\\ \///\/   ///\  /         ///\  /       ///\\\  ///\  /
  ///  \\\///  \  ///  \/         ///  \/       ///  \\\///  \/
 ///\  / ///\  / ///\  /         ///////////\   \///////\\\  /
///  \/ ///  \/ ///  \/         ///////////  \  ///////  \\\/
\\\  /  \\\  /  \\\  /          \\\\\\\\\\\  /  \\\\\\\  /
 \\\/    \\\/    \\\/            \\\\\\\\\\\/    \\\\\\\/

Yabasic

// Method 1
// r$ = system$("explorer \"http://www.network-science.de/ascii/ascii.php?TEXT=${delegate}&x=23&y=10&FONT=block&RICH=no&FORM=left&STRE=no&WIDT=80&TEXT=Yabasic\"")

// Method 2
// print
// print " _|      _|          _|                            _|            "
// print "   _|  _|    _|_|_|  _|_|_|      _|_|_|    _|_|_|        _|_|_|  "
// print "     _|    _|    _|  _|    _|  _|    _|  _|_|      _|  _|        "
// print "     _|    _|    _|  _|    _|  _|    _|      _|_|  _|  _|        "
// print "     _|      _|_|_|  _|_|_|      _|_|_|  _|_|_|    _|    _|_|_|  "
// print

// Method 3
clear screen

dim d$(5)

d$(0) = "X    X   X   XXXX     X    XXX  X  XXX "
d$(1) = " X  X   X X  X   X   X X  X     X X   X"
d$(2) = "  X    XXXXX XXXX   XXXXX  XXX  X X    "
d$(3) = "  X    X   X X   X  X   X     X X X   X"
d$(4) = "  X    X   X XXXX   X   X XXXX  X  XXX "

long = len(d$(0))

sub write(dx, dy, c$)
	local x, y
	
	for y = 0 to 4
		for x = 0 to long
			if mid$(d$(y), x, 1) = "X" print at(x + dx, y + dy) c$
		next x
	next y
end sub

write(2, 2, "\\")
write(1, 1, "#")
print

zkl

Translation of: Common Lisp
#<<<
"
xxxxxx  x   x  x
    x   x  x   x
  x     x x    x
x       x  x   x
xxxxx   x   x  xxxx
"
#<<<<
.replace(" ","  ").replace("x","_/").println();
Output:

_/_/_/_/_/_/    _/      _/    _/
        _/      _/    _/      _/
    _/          _/  _/        _/
_/              _/    _/      _/
_/_/_/_/_/      _/      _/    _/_/_/_/
Retrieved from "https://rosettacode.org/wiki/Write_language_name_in_3D_ASCII?oldid=361032"