[Question]
  [
# or: Build a vertical quine
Inspired by [Take a stand against long lines](https://codegolf.stackexchange.com/q/124259/9365).
Your task is to build a vertical quine with as short a line length as possible.
## Scoring
Shortest line length (excluding newlines) wins, with [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") criteria as a tie-breaker.
Line length is determined as the longest line in your program excluding the line break character.
For example:
```
$_=
Q.
P
```
has a line length of 3 and a byte count of 8, whilst:
```
Q
$
_
P
```
Has a line length of 1 and a byte count of 7 (assuming no trailing newline).
## Rules
Quines must meet the [community definition of a quine](https://codegolf.meta.stackexchange.com/a/4878/9365).
[Standard loopholes](https://codegolf.meta.stackexchange.com/q/1061/9365) are forbidden.
  
[Answer]
# [Lenguage](http://esolangs.org/wiki/Lenguage), line length 0, ≈ 1.01 × 10805 bytes
The source code consists of 
> 
> 10124204951141713202533972929121310016060433092338061822344361345785088607872212687519180665846846689047959498775873817205954910072327976407177053174071436371843670134990737172675632938993247496933911137703773908536875512359091727633452506044935740750830240213878294804481182083555147915724921824921475110508228264569693355158523956426011218344830576542194309867719995259333487662608933990607888012376767799159279952780093033761421596267435996052643805835600325453580090964941176722519904997142820547696122795384058768166716813179490118821654787005844786013890425692181280317909786461426684986082270532414940905922244777135016193088362341771414388821075092853157152933099269703875111747946164773211049512395358715902962437487134522781505709420586981997748912591875626029183292826655753251235587052422561943 
> 
> 
> 
linefeeds, which encodes the brainfuck program that follows.
```
>>++++++++>+++>+++>+>+>+>+>+>+>+>+++>+>+>+>+>+>+>+>+>+++>+>+>+>+>+>+>+>+>++++++++>++++>++++++++>++++>+++++++>++>+++>+>+++>++>+++>+++>+>+>+>+>+>+>+>+>++++>++++>+++++++>+>++++>++++++++>++>+++++++>+++>++++++++>++>+++++++>+++>++++++++>++>+++++++>+++>++++++++>++>+++++++>+++>++++++++>++>+++++++>+++++>+>+>+>+>+>+>+>+>+>+>++++++++>++++>+++++++>+++++++>+>+>+++>+>+>+>++++++++>+++>+++++++>+>+++>+>+++>+>+++>+>++++++++>++++>++++++++>++++>++++++++>++++>++++>+>+++>+++>++>+++++++>+++++++>+>+>+>++++++++>+++>+>++++++++>++++>+>+++>++>+++++++>++>+++++++>++++>++++>++++++++>+++>++++++++>+++>+++>+>++++>++++>++>+++++++>+++>+++>++++++++>++++>+>+++>++>+++++++>++++>++++>+++++++>+++>+++>+++>+++>++++++++>++++>++++>+>+++>+>+++>++>+++++++>+++++++
[
    [->+>+<<]
    >>>>[<<[->+<]>>[-<<+>>]>]
    <<[-[->+<]+>]+++
    [[->>+<<]<]<
]
+>+>+>+
[>]+++>++
[
    [<]++++++++++.[-]
    >[-]>[-]>[-]>[-]
    <+[<<++++++++>>->+>-[<]<]
    ++++++++>++++++++>+++++++>>
]
```
The source code is mostly identical to [@jimmy23013's radiation-softened Lenguage quine](https://codegolf.stackexchange.com/a/73729/12012), minus the `.` at the end, with `++++++++++.[-]` replacing `.` to print linefeeds instead of null bytes, and the corresponding changes to the data section on line 1.
[Answer]
# JavaScript, line length 1, ~~960~~ ~~956~~ 928 bytes
```
[
t
,
r
,
u
,
e
,
f
,
a
,
l
,
s
]
=
!
0
+
[
!
1
]
;
[
,
n
,
d
,
,
q
,
i
]
=
t
.
a
+
t
V
=
[
]
[
f
+
i
+
n
+
d
]
;
[
,
,
,
c
,
,
,
o
,
,
_
,
,
,
,
,
y
,
z
]
=
V
+
0
F
=
V
[
E
=
c
+
o
+
n
+
s
+
t
+
r
+
u
+
c
+
t
+
o
+
r
]
P
=
(
1
+
e
+
2
+
3
-
4
+
t
)
[
2
]
f
=
F
(
r
+
e
+
t
+
u
+
r
+
n
+
_
+
a
+
t
+
o
+
(
0
+
{
}
)
[
3
]
)
(
)
(
3
*
4
+
[
]
[
E
]
[
n
+
a
+
(
0
[
E
]
+
0
)
[
9
+
2
]
+
e
]
)
[
1
]
F
(
a
,
a
+
l
+
e
+
r
+
t
+
y
+
a
+
P
+
q
+
P
+
a
+
P
+
q
+
z
)
`
[
t
,
r
,
u
,
e
,
f
,
a
,
l
,
s
]
=
!
0
+
[
!
1
]
;
[
,
n
,
d
,
,
q
,
i
]
=
t
.
a
+
t
V
=
[
]
[
f
+
i
+
n
+
d
]
;
[
,
,
,
c
,
,
,
o
,
,
_
,
,
,
,
,
y
,
z
]
=
V
+
0
F
=
V
[
E
=
c
+
o
+
n
+
s
+
t
+
r
+
u
+
c
+
t
+
o
+
r
]
P
=
(
1
+
e
+
2
+
3
-
4
+
t
)
[
2
]
f
=
F
(
r
+
e
+
t
+
u
+
r
+
n
+
_
+
a
+
t
+
o
+
(
0
+
{
}
)
[
3
]
)
(
)
(
3
*
4
+
[
]
[
E
]
[
n
+
a
+
(
0
[
E
]
+
0
)
[
9
+
2
]
+
e
]
)
[
1
]
F
(
a
,
a
+
l
+
e
+
r
+
t
+
y
+
a
+
P
+
q
+
P
+
a
+
P
+
q
+
z
)
`
```
More readable version which also happens to be a quine (extraneous newlines removed):
```
[t,r,u,e,f,a,l,s]=!0+[!1];[,n,d,,q,i]=t.a+t
V=[][f+i+n+d];[,,,c,,,o,,_,,,,,y,z]=V+0
F=V[E=c+o+n+s+t+r+u+c+t+o+r]
P=(1+e+2+3-4+t)[2]
f=F(r+e+t+u+r+n+_+a+t+o+(0+{})[3])()(3*4+[][E][n+a+(0[E]+0)[9+2]+e])[1]
F(a,a+l+e+r+t+y+a+P+q+P+a+P+q+z)`
[t,r,u,e,f,a,l,s]=!0+[!1];[,n,d,,q,i]=t.a+t
V=[][f+i+n+d];[,,,c,,,o,,_,,,,,y,z]=V+0
F=V[E=c+o+n+s+t+r+u+c+t+o+r]
P=(1+e+2+3-4+t)[2]
f=F(r+e+t+u+r+n+_+a+t+o+(0+{})[3])()(3*4+[][E][n+a+(0[E]+0)[9+2]+e])[1]
F(a,a+l+e+r+t+y+a+P+q+P+a+P+q+z)`
```
### Explanation
Whew. Settle in for a ride here, because this is gonna be a treacherous journey...
I spent a long time trying to figure out how to solve this challenge with length 1—no built-ins (directly, anyway), keywords, or even arrow functions—before realizing that it is easily possible with [JSF\*\*\*](http://www.jsfuck.com/), which can evaluate any JavaScript code while avoiding any multi-byte tokens. But a JSF solution would easily be thousands of bytes long, if not tens or hundreds of thousands. Thanksfully, we aren't limited to just `()[]+!`—we have all of ASCII at our disposal!
I decided to start by golfing the essential building blocks of JSF—the characters that can be built up into strings to "unlock more features," so to speak. We can't use strings directly to get characters, as that would require lines of length 3. So instead, we steal a trick from JSF, getting a few chars from literals that can be built up with single-byte tokens:
```
JSF***   Used here   Value        Chars unlocked
!![]     !0          true         true
![]      !1          false        fals
[][[]]   t.a         undefined    ndi
```
From these we can expand outward, starting with `[].find`, which is a Function object. Converting this to a string `function find() { ...` gives us access to `c`, `o`, space (`_`), and parentheses (`y` and `z`). Perhaps more importantly, we now have access to its `constructor`, the `Function` function—which, inceptional as it may sound, gives us the ability to execute code by building a string, passing it to `Function()`, and then calling the function generated.
I should probably mention the overall method used by the program itself. As of 2015, JavaScript has this really cool feature called "[tagged templates](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals)," which not only allows unescaped newlines in strings, but also lets us call a function with a string literal directly (in a way; `myFunc`abc`;` is roughly equivalent to `myFunc(["abc"])`). If we put the function call as the last thing in the program, the general structure will look like this:
```
code;func`code;func`
```
All `func` has to do then is output its argument, followed by a backtick, then its argument again, and a second backtick. Assuming we have the argument in `a` and a backtick stored in `f`, we can accomplish this with the code `alert(a+f+a+f)`. However, at the moment, we are missing `+` and the backtick itself. `+` (stored in `P`) isn't hard; we steal another trick from JSF, building the string `1e23`, converting to a number, then back to a string, giving `"1e+23"`.
Getting a backtick is a bit more complicated. At first, I tried obtaining `String.fromCharCode`, but finding a `C` turned out to be nearly as difficult. Fortunately, `atob` is easy enough to obtain (`Function("return atob")()`; `b` is generated from `0+{}`, which gives `[object Object]`) and can give any ASCII char, if a proper magic string is found. A short script gave me `12A` as one of the options, which can conveniently be found in `12Array` (a bit shorter to generate, thanks to `[].constructor[n+a+m+e]`; `m` is found in `0 .constructor+0`: `"function Number() { ..."`).
Finally, we stick everything together. We assign the backtick to variable `f`, but since we can't use it directly in the function string, we instead set variable `q` to the letter `f` and use that instead. This makes our final string `a+l+e+r+t+y+a+P+q+P+a+P+q+z`, or `"alert(a+f+a+f)"`. We then feed this to `Function()`, feed the our finished code to the result, and voila, we have a JavaScript quine with no more than one char per line!
---
My head feels terrible at the moment, so please inquire about any mistakes I've made or things I've missed in this explanation, and I'll get back to you after I've had some rest...
[Answer]
# [Haskell](https://www.haskell.org/), line length 6, ~~400~~ ~~343~~ 336 bytes
```
{main=
putStr
$s++(s
>>=(++
":\n")
.show)
++
"[]}";
s='{':
'm':
'a':
'i':
'n':
'=':
'\n':
'p':
'u':
't':
'S':
't':
'r':
'\n':
'$':
's':
'+':
'+':
'(':
's':
'\n':
'>':
'>':
'=':
'(':
'+':
'+':
'\n':
'"':
':':
'\\':
'n':
'"':
')':
'\n':
'.':
's':
'h':
'o':
'w':
')':
'\n':
'+':
'+':
'\n':
'"':
'[':
']':
'}':
'"':
';':
'\n':
's':
'=':
[]}
```
[Try it online!](https://tio.run/##bdA9CoQwEAXgfo4RBJWAB1DiJSzVwmIhsv7hKBbi2eO@yE5g2eZj8vIIQ2zH79cwOHeOXT8ZWvat2laKWOuEqSxNojWpvJlUShnb@UgJQd1eqiA28RnnFI@gAz2YgAGNHxewgw1UMq2hEwEGWkgkezqlYOQ6tJ@OArk/N7KLD9NQyuRhC2Zw/HT@PlyDFlySFaHD390@3@PcDQ "Haskell – Try It Online") I'm not aware of a way around `putStr`, thus the line length of 6. The outer curly braces allow to get rid of the otherwerwise required indention after a newline within a single declaration.
[Answer]
# [><>](https://esolangs.org/wiki/Fish), 22 bytes, line length 1
```
/
v
o
a
o
^
}
-
d
:
"
```
[Try it online!](https://tio.run/##S8sszvj/X5@rjCufKxGI47hquXS5UrisuJS4/v8HAA "><> – Try It Online")
-6 bytes thanks to [Emigna](https://codegolf.stackexchange.com/users/47066/emigna).
[Answer]
# [CJam](https://sourceforge.net/p/cjam), line length 1, ~~16~~ 13 bytes
```
"
_
p
"
_
p
```
[Try it online!](https://tio.run/##S85KzP3/X4krnquAS4kLTP3/DwA "CJam – Try It Online")
It's a small miracle that inserting newlines into the ~~standard quine `{"_~"}_~`~~ even shorter standard quine `"_p"␊_p` does the right thing. (Thanks, Martin!) The trailing newline is necessary.
## Explanation (with • as newline)
```
"•_•p•"        Push that string.
       ••      Do nothing.
         _     Duplicate the string.
          •    Do nothing.
           p   Pop it and print it with quotes and a newline: "•_•p•"•
            •  Do nothing.
```
On termination, what's left on the stack is printed (`•_•p•`), yielding total output `"•_•p•"••_•p•`.
[Answer]
# [Haskell](https://www.haskell.org/) + CPP, line length 2, ~~705~~ 237 bytes
```
m\
a\
i\
n\
=\
p\
u\
t\
S\
t\
r\
$\
(\
:\
"\
\\
\\
\\
n\
"\
)\
=\
<\
<\
s\
+\
+\
s\
h\
o\
w\
 \
s\
;\
s\
=\
"\
m\
a\
i\
n\
=\
p\
u\
t\
S\
t\
r\
$\
(\
:\
\\
"\
\\
\\
\\
\\
\\
\\
n\
\\
"\
)\
=\
<\
<\
s\
+\
+\
s\
h\
o\
w\
 \
s\
;\
s\
=\
"\
```
[Try it online!](https://tio.run/##nY0xCsJQFAT7PYWIhUG8QGIqLxCwsZjmE9SE/CTiN3h7X@SBoJ0Iw7JbLNOE1J1iNOtRQC0aUImuaEJ3dPC8oRVaoxwtEW8Gn5lfdk5CG@dVGjSiB1r4LDxLv/yu49v4qeZfu9mzPsdwSbY97qtqBg "Haskell – Try It Online") Using the flag `-CPP` which enables the C pre-processor allows us to use a backslash at the end of a line to continue it on the next line.
The actual code is `main=putStr$(:"\\\n")=<<s++show s;s="<data>"`.
*Edit: A casual -468 bytes thanks to [Ørjan Johansen](https://codegolf.stackexchange.com/users/66041/%c3%98rjan-johansen)!*
[Answer]
# Rust, line length: 5, bytes: ~~301~~ 299
[Try it online](https://play.rust-lang.org/?gist=73e5bd7828dead1a2c11c81db45c348b&version=stable)
Despite how it looks, this isn't an esoteric programming language, there is just a lot of format line noise.
Vertical length of 5 was chosen to be able to use `print`. I don't think there is a way to print that would have shorter vertical length, declaring C functions uses `extern` keyword, `stdout` is 6 bytes long, `write` is 5 bytes long, `no_main` is 7 bytes long (main is usually a function ;)).
```
fn
main
(){
let
t=(
r#"fn
main
(){
let
t=("#
,r#")
;
print
!(
r#"{}
r#"{
}"{}
,r#"{
}"{},
r#"{
}"{}
{}{}{
}{
}""#,
r#"
,t.0,
t.0,
'#',
t.1,
'#',
t.2,
'#',
t.1,
'#',
t.2,
'}'
)"#
)
;
print
!(
r#"{}
r#"{
}"{}
,r#"{
}"{},
r#"{
}"{}
{}{}{
}{
}"#
,t.0,
t.0,
'#',
t.1,
'#',
t.2,
'#',
t.1,
'#',
t.2,
'}'
)}
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), Line length: 1, Byte count: 43
```
2
"
D
3
4
«
ç
¶
ì
ý
Ô
"
D
3
4
«
ç
¶
ì
ý
Ô
```
[Try it online!](https://tio.run/##MzBNTDJM/f/fiEuJy4XLmMuE69BqrsPLuQ5t4zq8huvwXq7DU/DIcP3/DwA "05AB1E – Try It Online")
[Answer]
# [Japt](https://github.com/ETHproductions/japt), line length 1, 20 bytes
Based off the [standard Japt quine by ETHproductions](https://codegolf.stackexchange.com/a/71932/59487).
```
"
i
Q
 
²
"
i
Q
 
²
```
**[Try it here!](https://ethproductions.github.io/japt/?v=master&code=IgppClEKIAqyCiIKaQpRCiAKsgo=&input=)**
[Answer]
# JavaScript (ES6), line length 3, 17 bytes
```
f=
_=>
`f=
${f
}`
```
[Answer]
# [Red](http://www.red-lang.org), line-length: 10, 49 bytes
```
s: [prin [
    "s:"
    mold s
    "do s"
]] do s
```
[Try it online!](https://tio.run/##K0pN@R@UmqIQHfu/2EohuqAoM08hmksBCJSKrZTAjNz8nBSFYohYSr5CsRJXbKwCiPH/PwA "Red – Try It Online")
This in fact is a [Rebol](https://rosettacode.org/wiki/Quine#REBOL) quine
Explanation:
Red/Rebol's `mold` follows the coding style of putting 4 spaces offset.
```
s: [prin [     ; s is a block; print the following: 
    "s:"       ; literal "s:"
    mold s     ; the representation of the block itself - all between []
    "do s"     ; literal "do s"
]] do s        ; evaluate the block
```
[Answer]
# [RProgN](https://github.com/TehFlaminTaco/Reverse-Programmer-Notation), 3 bytes, line length 1
```
0
0
```
[Try it online!](https://tio.run/nexus/rprogn#@2/AZfD/PwA "RProgN – TIO Nexus")
A copy of Dennis' answer [here](https://codegolf.stackexchange.com/a/103262/76162) (go upvote him too)
This is a conforms to our [current definition](https://codegolf.meta.stackexchange.com/questions/4877/what-counts-as-a-proper-quine/4878#4878) of a proper quine, as the first 0 encodes the second 0 and vice-versa. 
[Answer]
# [RProgN 2](https://github.com/TehFlaminTaco/RProgN-2), L = 1, B = 15 bytes
```
«
Ø
.
`
-
S
`
.
```
This is equivilent to the program:
```
«Ø.`
-S`
.
```
## Breakdown
`«` first pushes a function representing implicitly the rest of the program to the stack, and then continues execution. `Ø.` appends an empty string to the function, which stringifies it. This will always stringify like the equivilent program, due to newlines being no-ops. ``\n-` Removes all newlines from the string, now looking like `«Ø.`=S`.`. `S` then converts it to a stack of single characters, and ``\n.` joins the stack by newlines, returning the expected program.
[Try it online!](https://tio.run/##Kyooyk/P0zX6///Qaq7DM7j0uBK4dLmCgaTe//8A "RProgN 2 – Try It Online")
[Answer]
# [Underload](https://github.com/catseye/stringie), line length 1, 20 bytes
```
(
:
a
S
S
)
:
a
S
S
```
[Try it online!](https://tio.run/##K81LSS3KyU9M@f9fg8uKK5ErGAg14az//wE "Underload – Try It Online")
This is just the standard Underload quine with newlines appended. Requires an implementation like the TIO one which ignores unknown command characters.
The part in `()` is a string literal put on the stack, `:` duplicates it, `a` wraps the top stack entry in parentheses, and `S` prints.
[Answer]
# [Perl 5](https://www.perl.org/), 259 bytes
```
$
_
=
p
.
r
.
i
.
n
.
t
.
q
{
'
$
_
=
p
.
r
.
i
.
n
.
t
.
q
{
'
,
&
{
I
.
"
X
0
y
h
~
"
^
"
E
O
0

y
"
.
x
}
(
$
_
,
6
,
-
1
)
,
'
}
;
&
{
I
.
"
X
0
o
k
h
~
"
.
(
Y
|
p
)
^
"
E
O
0
|
f
s
o
"
}
'
}
;
&
{
I
.
"
X
0
o
k
h
~
"
.
(
Y
|
p
)
^
"
E
O
0
|
f
s
o
"
}
```
[Try it online!](https://tio.run/##pY6xDgFREEX78xkvYm2yNhQ0olSotDRUhBB2l4JYfPpzIgrRKBQnM3Nn7s0Uy2rXi5EGC4YU5FSykb2cpOQKyY@DhIymdewcmNLhwpq7/VxGTFQeasH9mRutV15GX9p0Sa2J@uAr5cD2nZPrmVH7QfqRWbPi6FXQ@6c/xic "Perl 5 – Try It Online")
[Verification](https://tio.run/##7VFNCwFRFN37Fa9JhjJigcVkaWFlS52IMRrh@Czk468/rzMpJQsbUbM5vXfvPefc2xmPdom1cZSsTMDY@GAeHIItcA1WwK1wJqRwL9yAZ7iCD/9TUkopgwV9O2p5YA@sgicwAW@qDIRtsKsWjs2pBjxRjuAVLD7cnWBDGIA1sKR36uXGwjd2K3D@5FiRYB@86JbSyw6u7nbYiehJ@RsW5mKWk3qYy2VJ/X5S63i7yAL7o8AOkQmi0No7 "Bash – Try It Online").
[Answer]
# Javascript (ES6 REPL), full-program, line-length: 3, byte-count: 31
```
(
f=
_=>
`(
f=
${f
}
)
()`
)
()
```
This is a port of @kamoroso94's answer to a self-contained full program.
If anybody finds a way to strip off some bytes without adding more to the line-length feel free to comment :)
[Answer]
# [Pip](https://github.com/dloscutoff/pip), line length 1, 35 bytes
```
V
Y
"
[
`
V
Y
`
y
]
.
C
:
3
.
4
"
```
[Try it online!](https://tio.run/##K8gs@P@fK4wrkkuJK5orAcxK4KrkiuXS43LmsuIyBtImQLn//wE "Pip – Try It Online")
Based on the shortest known Pip quine, `V Y"`V Y`.RPy"`. The main difficulty in squishing it to line length 1 is `RP`, which can't be split over two lines. But in this case, all `RP` (repr) does is wrap the string in double quotes, which we can do directly.
Here's an explanation based on a horizontal version:
```
V Y"[`V Y`y].C:3. 4"
  Y"               "  Yank this string into the variable y
V                     and eval it
                      The code that is eval'd:
    [      ]           Build a list containing:
     `V Y`              this Pattern object (used for regex, but here useful as a
                          string-like object that doesn't need double quotes)
          y             y, the whole string
               3. 4    Concatenate 3 and 4 to make 34 (since the 2-digit number won't work
                         in the vertical version)
             C:        Convert to ASCII character (: forces the precedence lower than .)
            .          Concatenate the " to the end of each list element
                      The resulting list is printed, concatenated together, with a
                        trailing newline
```
[Answer]
# [Befunge-98](https://pythonhosted.org/PyFunge/), 41 bytes
```
^
@
,
,
a
-
1
*
5
7
|
 
#
!
a
#
:
,
^
$
"
```
[Try it online!](https://tio.run/##S0pNK81LT9W1tNAtqAQz//@P43Lg0gHCRC5dLkMuLS5TLnOuGi4FLmUuRaCYMpcVUC6OS4VL6f9/AA "Befunge-98 (PyFunge) – Try It Online")
Really just a normal quine turned sideways, with some extra stuff to print newlines.
]