[Question]
  [
Your task is simple: Write a program (or function) that takes no input and outputs something like this:
```
## *name*, *length* bytes
    *code*
```
Where `*name*` is the name of the language you are using, `*length*` is the number of bytes in your code, and `*code*` is your program's source code. If `*code*` contains multiple lines, it have four spaces before each line.
Here's a 124-byte example implementation in Python 3:
```
s = "## Python 3, 124 bytes{2}    s = {1}{0}{1}{2}print(s.format(s,chr(34),chr(10)))"
print(s.format(s,chr(34),chr(10)))
```
The output is:
```
## Python 3, 124 bytes
    s = "## Python 3, 124 bytes{2}    s = {1}{0}{1}{2}print(s.format(s,chr(34),chr(10)))"
    print(s.format(s,chr(34),chr(10)))
```
Which in Markdown is:
> 
> ## Python 3, 124 bytes
> 
> 
> 
> ```
> s = "## Python 3, 124 bytes{2}    s = {1}{0}{1}{2}print(s.format(s,chr(34),chr(10)))"
> print(s.format(s,chr(34),chr(10)))
> 
> ```
> 
> 
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest answer (in bytes) wins.
  
[Answer]
# RProgN 2, 28 Bytes
```
«"  %s"F"#RProgN 2, 28 Bytes"
```
[Answer]
# Underload, 48 bytes
```
(#Underload, 48 bytes
)(~:S(    ):S*aSaS(:^)S):^
```
[Answer]
## Python 2, 58 bytes
```
_='## Python 2, 58 bytes\n    _=%r;print _%%_';print _%_
```
[Answer]
## reticular, 58 bytes
```
"'34'c: 4*91+c:s:e:t:y:b: 85: :,:r:a:l:u:c:i:t:e:r: :#dqO;
```
[Try it online!](http://reticular.tryitonline.net/#code=IiczNCdjOiA0KjkxK2M6czplOnQ6eTpiOiA4NTogOiw6cjphOmw6dTpjOmk6dDplOnI6IDojZHFPOw&input=)
Explanation: `:c` pushes the single-char string `c`. This builds the string "## reticular, 58 bytes", backwards character by character, reverses the stack, and `O`utputs everything, including the string captured by the initial quote.
[Answer]
## CJam, 33 bytes
```
{"## CJam, 33 bytes"N@S4*\"_~"}_~
```
Works a lot like the Underload answer.
Stack trace (`N` represents `\n`)
```
{"## CJam, 33 bytes"N@S4*\"_~"}
{"## CJam, 33 bytes"N@S4*\"_~"} {"## CJam, 33 bytes"N@S4*\"_~"}
{"## CJam, 33 bytes"N@S4*\"_~"} "## CJam, 33 bytes"
{"## CJam, 33 bytes"N@S4*\"_~"} "## CJam, 33 bytes" N
"## CJam, 33 bytes" N {"## CJam, 33 bytes"N@S4*\"_~"}
"## CJam, 33 bytes" N {"## CJam, 33 bytes"N@S4*\"_~"} " "
"## CJam, 33 bytes" N {"## CJam, 33 bytes"N@S4*\"_~"} " " 4
"## CJam, 33 bytes" N {"## CJam, 33 bytes"N@S4*\"_~"} "    "
"## CJam, 33 bytes" N "    " {"## CJam, 33 bytes"N@S4*\"_~"}
"## CJam, 33 bytes" N "    " {"## CJam, 33 bytes"N@S4*\"_~"} "_~"
<implicit output>
```
[Answer]
# V, 25 bytes
```
ñi#V, 25 bytes<esc>o´ Ñ<esc>~"qpx
```
---
(This is not counted in the generated markdown, because I like providing explanations for my code :P)
Here is a hexdump, since the source code contains unprintable/non-ASCII characters:
```
00000000: f169 2356 2c20 3235 2062 7974 6573 1b6f  .i#V, 25 bytes.o
00000010: b420 d11b 7e22 7170 78                   . ..~"qpx
```
This answer is just a trivial modification of the standard [extensible V quine](https://codegolf.stackexchange.com/a/100426/31716).
Explanation:
```
ñ                                   " Run the following code one time, storing it in
                                    " register 'q'
 i                                  "   Enter insert mode
  #V, 25 bytes<esc>                 "   And insert the header
                   o                "   Open up a newline, and enter insert mode again
                    ´ Ñ             "   Enter four spaces, then a 'Ñ' character.
                                    "   (The reason we insert it uppercase, is because
                                    "   lowercase would end the loop now)
                       <esc>        "   Return to normal mode
                            ~       "   Toggle the case of the char under the cursor ('Ñ')
                             "qp    "   Paste the contents of register 'q' (this is the
                                    "   same as the entire program minus the initial 'ñ',
                                    "   followed by a 'ÿ' character because V is weird)
                                x   "   Delete the last character (the ÿ)
```
[Answer]
# JS, ~~50~~ ~~49~~ ~~27~~ 30 bytes
```
f=_=>`#JS, 30 bytes\n    f=`+f
```
---
## Try It
```
f=_=>`#JS, 30 bytes\n    f=`+f
console.log(f())
```
[Answer]
# [Go](https://go.dev), 102 bytes
```
import.`fmt`;func f(){s:="## Go, 102 bytes\n    import.`fmt`;func f(){s:=%q;Printf(s,s)}";Printf(s,s)}
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m70oPX_BmoLE5OzE9FSF3MTMvKWlJWm6FjfTMnML8otK9BLScksSrNNK85IV0jQ0q4utbJWUlRXc83UUDA2MFJIqS1KLY_IUgACnetVC64CizLySNI1inWLNWiUUHsS2TWD1INuBWriA-rigEgsWQGgA)
From my variant in a [comment](https://codegolf.stackexchange.com/questions/69/golf-you-a-quine-for-great-good/123763#comment564137_123763) under the post below. A callable function. Prints:
```
## Go, 102 bytes
    import.`fmt`;func f(){s:="## Go, 102 bytes\n    import.`fmt`;func f(){s:=%q;Printf(s,s)}";Printf(s,s)}
```
## [Go](https://go.dev), 134 bytes
```
package main;import.`fmt`;func main(){s:="## Go, 134 bytes\n    package main;import.`fmt`;func main(){s:=%q;Printf(s,s)}";Printf(s,s)}
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m70oPX_BgqWlJWm6FjfbChKTsxPTUxVyEzPzrDNzC_KLSvQS0nJLEqzTSvOSwcIamtXFVrZKysoK7vk6CobGJgpJlSWpxTF5CkBAtH7VQuuAosy8kjSNYp1izVolFB7ENVBHwRwHAA)
Using the quine found [here](https://codegolf.stackexchange.com/a/123763/77309). A full program. Prints:
```
## Go, 134 bytes
    package main;import.`fmt`;func main(){s:="## Go, 134 bytes\n    package main;import.`fmt`;func main(){s:=%q;Printf(s,s)}";Printf(s,s)}
```
[Answer]
# [Factor](https://factorcode.org/), 80 bytes
```
"# Factor, 80 bytes\n    %uUSE: formatting dup printf"USE: formatting dup printf
```
[Try it online!](https://tio.run/##S0tMLskv@h8a7OnnbqWQnVqUl5qjYP1fSVnBDSyjo2BhoJBUWZJaHJOnAASqpaHBrlYKaflFuYklJZl56QoppQUKBUWZeSVpSril/v8HAA "Factor – Try It Online")
]