[Question]
  [
Write a function (or a whole program) that outputs (or prints) the following ASCII art:
### Output:
```
                    1
            1       2       1
      1      2      3      2      1
  1     2     3     4     3     2     1
1    2    3    4    5    4    3    2    1
1   2   3   4   5   6   5   4   3   2   1
  1  2  3  4  5  6  7  6  5  4  3  2  1
      1 2 3 4 5 6 7 8 7 6 5 4 3 2 1
            12345678987654321
      1 2 3 4 5 6 7 8 7 6 5 4 3 2 1
  1  2  3  4  5  6  7  6  5  4  3  2  1
1   2   3   4   5   6   5   4   3   2   1
1    2    3    4    5    4    3    2    1
  1     2     3     4     3     2     1
      1      2      3      2      1
            1       2       1
                    1
```
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest solution in bytes wins!
#### Allowed:
* Any number of **trailing spaces** on each line
* An equal number of *additional* **leading spaces** on each line (meaning of additional: without counting the already mandatory leading spaces shown in the output above)
* *Additional* **newlines** at the beginning and/or at the end. These additional lines can contain any number of spaces
---
I'm late to the party, but as some of you may have recognized, this challenge is inspired by the bugged output in [*Carcigenicate*'s answer in Clojure](https://codegolf.stackexchange.com/a/109197/52210) for the [Print this diamond](https://codegolf.stackexchange.com/questions/8696/print-this-diamond) challenge.
This answer also led to a chain of 3 challenges from [*Kevin Cruijssen*](https://codegolf.stackexchange.com/users/52210/kevin-cruijssen) : [It was just a bug](https://codegolf.stackexchange.com/questions/129523/it-was-just-a-bug), [It was just an input-bug](https://codegolf.stackexchange.com/questions/129925/it-was-just-an-input-bug), and [I done did made a spaceship maw!](https://codegolf.stackexchange.com/questions/171679/i-done-did-made-a-spaceship-maw)
But i wanted to see something more "pulsar-y", as this is what i find most beautiful in the original answer!
I hope you will generate beautifully bugged ASCII arts while doing this challenge :)
  
[Answer]
# [Python 3](https://docs.python.org/3.8/), 80 bytes
```
i=8
while i+9:k=abs(i);print(f"{(' '*k).join(str((10**(9-k)//9)**2)):^41}");i-=1
```
[Try it online!](https://tio.run/##BcHdCkAwFADge08hN8458jNcGO1VFEWOadasJHn2@T77@O00TWddCKy66N74WGLOZK/VNF/AOFjHxsOavJDGKWks9pMNXN4BiIoIZK6xLCUS1Yj92IovwYFzJUL4AQ "Python 3.8 (pre-release) – Try It Online")
Uses the classic arithmetic trick where, for example,
```
(10**9//9)**2 == 111111111**2 == 12345678987654321
```
## [Python 3](https://docs.python.org/3.8/), 79 bytes
```
f=lambda k=8,c=1:(s:=[f"{(' '*k).join(str(c*c)):^41}"])[k:]or s+f(k-1,c*10+1)+s
```
[Try it online!](https://tio.run/##FchBDsIgEADAu6/Y9NJdqEaih4aElzQ1qSgRaRcCXIzx7ahznPSqj8inMeXWnFmX7XpbIJhxsEZpLNpMrntjD70IdHhGz1hqRisskb6c1aebaQp6jhmKdBj2arBCHaUiWZr77er5Dp7BIekdpOy54v@ofQE "Python 3.8 (pre-release) – Try It Online")
Recursive function that generates a list of lines when called with no inputs. The idea is to start with the center line, then repeatedly sandwich what we have between two copies of a new line.
## [Python 3](https://docs.python.org/3.8/), 79 bytes
```
f=lambda p=8*' ',c=1:(s:=f"{p.join(str(c*c)):^41}\n")+(p and f(p[1:],c*10+1)+s)
```
[Try it online!](https://tio.run/##BcFBCoMwEADArwQv7iYiXepBAnmJWkgjoYquS5JLKb49nZFv@Vz8HCXVGt3hz/fqlbhRt6rtgiML2brY/KTfr40hlwRBB0T7GuieuUEDojyvKoJMZJcuaHoYQpOxStq4QATE@gc "Python 3.8 (pre-release) – Try It Online")
Recursive function that generates the whole multiline string, with a trailing newline, when called with no input.
[Answer]
# [Thunno 2](https://github.com/Thunno/Thunno2), 14 [bytes](https://github.com/Thunno/Thunno2/blob/main/docs/codepage.md)
```
9Rƒıṅ8_ṣjⱮ;ⱮØC
```
[Try it online!](https://Not-Thonnu.github.io/run#aGVhZGVyPSZjb2RlPTlSJUM2JTkyJUM0JUIxJUUxJUI5JTg1OF8lRTElQjklQTNqJUUyJUIxJUFFJTNCJUUyJUIxJUFFJUMzJTk4QyZmb290ZXI9JmlucHV0PSZmbGFncz0=)
~~Seems like the compressed list part (`¿qJŒḣ“ɲþẇɦɠ¿i`) could be golfed a bit with a formula, but I couldn't find it.~~
~~I found the formula \$(n-6)(n-5)\$ for the leading spaces.~~
I don't need that any more. Port of Kevin Cruijssen's 05AB1E answer.
*-5 by porting @KevinCruijssen's 05AB1E answer*
#### Explanation
```
9Rƒıṅ8_ṣjⱮ;ⱮØC  # Full program
9Rƒ             # Prefixes of [1..9]
   ı      ;     # Map over:
    ṅ8_         #  8 - iteration index
       ṣj       #  Join by that many spaces
         Ɱ      #  Palindromise
           Ɱ    # Palindromise
            ØC  # Center
                # Implicit output
```
Old:
```
9RⱮı65d-pṣnRⱮn9_ṣj+  # Full program
9RⱮı                 # Map over [1,2,...,8,9,8,...,2,1]:
    65d-pṣ           #  Push (n-6) * (n-5) spaces
          nRⱮ        #  Push [1,2,...,n,...2,1]
             n9_ṣj   #  Join by (9-n) spaces
                  +  #  Prepend the leading spaces
                     # Implicit output, joined on newlines
```
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 12 bytes
```
9ƛɾ9n-Ij;∞øṗ
```
[Try it Online!](https://vyxal.pythonanywhere.com/?v=2#WyIiLCIiLCI5xpvJvjluLUlqO+KInsO44bmXIiwiIiwiIl0=)
Uses the strangely specific `øṗ` (Flip Brackets Vertical Palindromise, Center, Join on Newlines) builtin.
```
9ƛ      ;         for n in [1...9]:
  ɾ9n-Ij            join [1..n] by 9-n spaces
         ∞        palindromize the list
          øṗ      palindromize and center all the strings and join by \n
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~71~~ 69 bytes
Function outputting an array of lines. A synthesis of my old answer with [Level River St](https://codegolf.stackexchange.com/users/15599/level-river-st)'s [answer](https://codegolf.stackexchange.com/a/263151/52194) as per their suggestions.
-2 bytes by switching to Ruby 2.7+ (TIO is on 2.5.5)
```
->{(-8..8).map{([*1...x=9-k=_1.abs,*x.downto(1)]*(' '*k)).center 41}}
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72kqDSpcsHiNNuYpaUlaboWN1117ao1dC309Cw09XITC6o1orUM9fT0KmwtdbNt4w31EpOKdbQq9FLyy_NK8jUMNWO1NNQV1LWyNTX1klPzSlKLFEwMa2shhq0uKC0pVkjTS07MyYGILFgAoQE)
# [Ruby](https://www.ruby-lang.org/), 77 bytes
Recursion, ahoy! Function outputting an array of lines.
```
f=->x=1{s=([*1...x,*x.downto(1)]*(' '*(9-x))).center 41;x<9?[s,*f[x+1],s]: s}
```
[Try it online!](https://tio.run/##BcFLDoMgEADQq7ATRphkEjdqsQchLOqHldHGgThN07PT964yf2pN3k3i6cteByBEFAuC63kf@dRkIuhGNaB7J8YYXLYjb5fqaJRH/wxsIQVpKVqOg@JffZfMKuHy2vf6Bw "Ruby – Try It Online")
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 17 bytes
```
Ｅ⁹⪫⮌…·¹⊕ι× ⁻⁸ι‖Ｏ¬
```
[Try it online!](https://tio.run/##DYxBCsIwEEX3nmLoagJx4U7tCRSKErxAiF8dSKclSXMqT@HFYt7yPXjh41NYfGztnkQLT37lk6XrIsoOFSmDLxrilqXCeX2DD5a6SZihBU8WYyw9ZEbmgQZLk@iW@Wiph864c3hFhHLrs9jv59/XjK21fY1/ "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
Ｅ⁹⪫⮌…·¹⊕ι× ⁻⁸ι
```
For `n` from `1` to `9`, output the numbers from `n` down to `1` joined with `9-n` spaces, but doing everything `0`-indexed.
```
‖Ｏ¬
```
Reflect both left and down to complete the diamond gone beautifully wrong.
[Answer]
# [Pip](https://github.com/dloscutoff/pip) `-l`, 23 bytes
```
QPZJ RZJ:R\,_JsX9-_M\,9
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m724ILNgWbSSbo5S7IKlpSVpuhbbAwOivBSCorysgmJ04r2KIyx1431jdCwhslBFC6A0AA)
### Explanation
```
QPZJ RZJ:R\,_JsX9-_M\,9
                    \,9  ; Range from 1 to 9, inclusive
                   M     ; Map this function to each:
          \,_            ;   Range from 1 to fn arg, inclusive
         R               ;   Reversed
             J           ;   Join on this string:
              sX         ;   A number of spaces equal to
                9-_      ;   9 minus fn arg
      ZJ:                ; Transpose list of strings, filling gaps with spaces
     R                   ; Reverse list of lines
  ZJ                     ; Transpose again
QP                       ; Quad-palindromize
                         ; Autoprint, joining on newlines (-l flag)
```
Here's the step-by-step evolution, using size 5 instead of 9 and showing spaces using periods:
```
\,5
1
2
3
4
5
R\,_JsX5-_M
1
2...1
3..2..1
4.3.2.1
54321
ZJ:
12345
....4
...33
..2.2
.1.21
.....
..11.
R
..11.
.....
.1.21
..2.2
...33
....4
12345
ZJ
......1
..1...2
1..2..3
1.2.3.4
..12345
QP
......1......
..1...2...1..
1..2..3..2..1
1.2.3.4.3.2.1
..123454321..
1.2.3.4.3.2.1
1..2..3..2..1
..1...2...1..
......1......
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 20 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
9Rjạ9⁶xƊƊ€Uz⁶ZUŒBŒḄY
```
A full program that prints the diamond.
**[Try it online!](https://tio.run/##y0rNyan8/98yKOvhroWWjxq3VRzrOtb1qGlNaBWQExV6dJLT0UkPd7RE/v8PAA "Jelly – Try It Online")**
### How?
```
9Rjạ9⁶xƊƊ€Uz⁶ZUŒBŒḄY - Main Link: no arguments
9                    - 9
         €           - for each {i in [1..9]}:
        Ɗ            -   last three links as a monad f(i):
 R                   -     range -> [1..i]
       Ɗ             -     last three links as a monad f(i):
   ạ9                -       absolute difference with 9 -> 9-i
     ⁶               -       space character
      x              -       repeat -> ' '*(9-i)
  j                  -     join -> e.g. "1      2      3"
          U          - reverse each
           z⁶        - transpose with space character as filler
             Z       - transpose
              U      - reverse each
               ŒB    - bounce each
                 ŒḄ  - bounce
                   Y - join with newline characters
                     - implicit, smashing print
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), 83 bytes
Updated per suggestion from @ValueInk
```
(-8..8).map{|i|puts (((-8+c=i.abs)..8-c).map{|j|"#{9-c-j.abs}"}*(" "*c)).center 41}
```
[Try it online!](https://tio.run/##KypNqvz/X0PXQk/PQlMvN7GguiazpqC0pFhBQwMoqp1sm6mXmFSsCZTWTYYqyKpRUq621E3WzQJJ1SrVamkoKShpJWtq6iWn5pWkFimYGNb@/w8A "Ruby – Try It Online")
# [Ruby](https://www.ruby-lang.org/), 86 bytes
```
(-8..8).map{|i|puts (((-8+c=i.abs)..8-c).map{|j|(9-c-j.abs).to_s}*(" "*c)).center(41)}
```
[Try it online!](https://tio.run/##KypNqvz/X0PXQk/PQlMvN7GguiazpqC0pFhBQwMoqp1sm6mXmFSsCZTWTYYqyKrRsNRN1s2CSJTkxxfXamkoKShpJWtq6iWn5pWkFmmYGGrW/v8PAA "Ruby – Try It Online")
[Answer]
# Swift, 156 bytes
`String(repeating:count)` is nice for practical code, but so long for code golf...
```
let f={(1...$0)+(1..<$0).reversed()}
f(9).map{n in print(.init(repeating:" ",count:(n-6)*(n-5))+f(n).map{"\($0)"+String(repeating:" ",count:9-n)}.joined())}
```
[Try it on SwiftFiddle!](https://swiftfiddle.com/ttgutsx66vdrfldkcc6dz3r2yy)
Port of @TheThonnu's various answers. `f` is a shorthand for counting from 1 to n and back. I put the joining spaces inside the `map` callback rather than passing them to `joined` because the latter would involve an extra argument label (`joined(separator:)`).
[Answer]
# [Scala](https://www.scala-lang.org/), 214 bytes
Port of [@Level River St's Ruby answer](https://codegolf.stackexchange.com/a/263151/110802) in Scala.
---
Golfed version. [Try it online!](https://tio.run/##pcxBDoIwEIXhvadoWM2IrUhc4AISD@DKE5SxwWIpjZ0YE8LZK8oR3L3F/71I2umUxrY3xOIizJuNv0VxDmECWQkeRYVq0GGydfPSTlBtlW7jJjytZ@cBMpFtoSwkLHlOyCNUknA1fd3ASZLsvwQVj1deWDer4bGunyZUzviO7/sS839uUEVnyUCxOx4Q5zmlDw)
```
object M extends App{(-8 to 8).map{i=>val c=i.abs
println((" "*(20-((-8+c)to(8-c)).map{j=>(9-c-j.abs).toString}.mkString(" "*c).length/2)+((-8+c)to(8-c)).map{j=>(9-c-j.abs).toString}.mkString(" "*c)).slice(0,41))}}
```
Ungolfed version. [Try it online!](https://tio.run/##XZA/T8MwFMT3fIpTJxva8EcMISJIjAxMFRNicB03dXCcKLZAUOWzh@c4garDk5K7n8/v7KQwYhzbXa2kx4vQFscEKNUeDf0w0Vcux1Pfi@@3re@1rd55jlerPYqJBNgmg2@R8bQRHY7QKB4nA/gUBpJAnYqdO9GMtopkFo5eQvJwnmXY0OeSUv@n0BX3waOpQxBPfRt3mYEhbT6iwFZY4YJiZqcj0RvLpLJe9Szcu8bdDY/@kMSZC88Q9Y1ha3zp0h9yPFvPF/GvdujRiXKrf0KViaQFXWqUrfxhQvSeLcRDgWuO@AbKOIV50wW4uuWcnsLRnDkUesJMGw/JOP4C)
```
object Main {
  def main(args: Array[String]): Unit = {
    (-8 to 8).map { i =>
      val c = i.abs
      val line = ((-8 + c) to (8 - c)).map { j =>
        (9 - c - j.abs).toString
      }.mkString(" " * c)
      println(center(line, 41))
    }
  }
  
  def center(s: String, width: Int): String = {
    val padSize = width - s.length
    if(padSize <= 0) s
    else (" " * (padSize/2)) + s + (" " * (padSize - padSize/2))
  }
}
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~16~~ 15 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
9Lηε8N-ð×ýû}û.c
```
[Try it online.](https://tio.run/##ASAA3/9vc2FiaWX//zlMzrfOtThOLcOww5fDvcO7fcO7LmP//w)
**Explanation:**
```
9L           # Push a list in the range [1,9]
  η          # Pop and push its prefixes: [[1],[1,2],[1,2,3],...]
   ε         # Map over each prefix:
    8N-      #  Push 8 minus the 0-based map index
       ð×    #  Pop and push a string of that many spaces
         ý   #  Join the list with those spaces (or empty string for N=8) as delimiter
          û  #  Palindromize this string
   }û        # After the map: palindromize the list of lines as well
     .c      # Join the list by newlines,
             # and add leading spaces where necessary to centralize the lines
             # (after which the result is output implicitly)
```
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 16 bytes
```
9ɾKėƛ÷$8εIj∞;∞øĊ
```
[Try it Online!](https://vyxal.pythonanywhere.com/?v=2#WyJqIiwiIiwiOcm+S8SXxpvDtyQ4zrVJauKInjviiJ7DuMSKIiwiIiwiIl0=)
Port of ~~my Thunno 2 answer~~ Kevin Cruijssen's 05AB1E answer.
*-1 thanks to @lyxal*   
*-3 by porting @KevinCruijssen's 05AB1E answer*
#### Explanation
```
9ɾKėƛ÷$8εIj∞;∞øĊ  # Full program
9ɾK               # Prefixes of [1..9]
   ėƛ       ;     # Enumerate and map over:
     ÷$8ε         #  Absolute difference between 8 and the iteration index
         Ij       #  Join by that many spaces
           ∞      #  Palindromise
             ∞    # Palindromise
              øĊ  # Center
                  # Implicit output
```
Old:
```
9ɾ∞ƛ65f-ΠInɾ∞n9εIj+  # Full program
9ɾ∞ƛ                 # Map over [1,2,...,8,9,8,...,2,1]:
    65f-ΠI           #  Push (n-6) * (n-5) spaces
          nɾ∞        #  Push [1,2,...,n,...2,1]
             n9εIj   #  Join by (9-n) spaces
                  +  #  Prepend the leading spaces
                     # Implicit output, joined on newlines
```
[Answer]
# [Perl 5](https://www.perl.org/), 65 bytes
```
$a=-1-abs,print map/\D|0/?$":$_,map$a+10+abs()/$a,-20..20for-8..8
```
[Try it online!](https://tio.run/##K0gtyjH9/18l0VbXUDcxqVinoCgzr0QhN7FAP8alxkDfXkXJSiVeB8hXSdQ2NNAGKtHQ1FdJ1NE1MtDTMzJIyy/StdDTs/j//19@QUlmfl7xf90cAA "Perl 5 – Try It Online")
I'd count it `63+1` (instead of `65`), the `+1` for `-E` and `say` instead of `print`, can't figure out how to get it in TIO which also doesn't add 1 for `-l` switch. But it beats direct competitors anyway :), it's strange nobody used this strategy.
[Answer]
# [JavaScript (V8)](https://v8.dev/), 102 bytes
A full program.
```
for(n=17;n--;print(s))for(q=n<9?n:16-n,x=9-q,i=s=''.padEnd(20-q*x);~q;)s+=`${++i>q?1+q--:i}`.padEnd(x)
```
[Try it online!](https://tio.run/##NcrBCsIwDADQnxHW2EWsB3WrcSf/Y8UhxEPWtGMURH@94sHr4z3DGvI9cVxwPdf6mJMRcicviD4mlsVkgJ8qyaUbpHdHlLZQh9oyZWqaXQzTTSZz2KNuC/iPesiWxs3LWr7q4Kwi9vwe/7FArV8 "JavaScript (V8) – Try It Online")
---
# [C (gcc)](https://gcc.gnu.org/), 116 bytes
*-1 thanks to [@c--](https://codegolf.stackexchange.com/users/112488/c)*
```
q;x;i;main(n){for(n=17;n--;i=!puts(""))for(q=n<9?n:16-n,x=9-q;~q;q-=i>q)printf("%*d",i>1?x:x+12-q*x+q,++i>q?1+q:i);}
```
[Try it online!](https://tio.run/##FcpBCsIwEADAtxgQkiZ7iAel3aZ5S4mkLOjabSsGRJ9u1PNMgimlWgULEl5HYs3mmW@L5uBPyABIYTfft1UrZcwfJHDfRu78EdiV0ILgW1Ag0CBmXoi3rNW@OStHg4@lK9YfQJpixVn7O9Fb6cjgq9ZPypdxWis8vg "C (gcc) – Try It Online")
[Answer]
# [Python 3](https://docs.python.org/3/), 107 bytes
```
R=range
for n in[*R(1,9),*R(9,0,-1)]:print((n-6)*(n-5)*' '+((9-n)*' ').join(map(str,[*R(1,n),*R(n,0,-1)])))
```
[Try it online!](https://tio.run/##K6gsycjPM/7/P8i2KDEvPZUrLb9IIU8hMy9aK0jDUMdSUwdIW@oY6OgaasZaFRRl5pVoaOTpmmlqAUlTTS11BXVtDQ1L3TwwU1MvKz8zTyM3sUCjuKRIB2JGHtiMPKgZmpqa//8DAA "Python 3 – Try It Online")
Port of my Thunno 2 answer.
*-5 thanks to @Neil*
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), 60 bytes
```
9* 
 
$`;$'¶
v`( *;)( *)
$.1$2
P`.+
%`^.
$^$<'
L$`9
$>`$^$`
```
[Try it online!](https://tio.run/##K0otycxLNPz/n8tSS4FLgUslwVpF/dA2rrIEDQUta00gocmlomeoYsQVkKCnzaWaEKfHpRKnYqPO5aOSYMmlYpcA5CX8/w8A "Retina – Try It Online") Explanation:
```
9* 
```
Insert 9 spaces.
```
 
$`;$'¶
```
Generate a `9×9` square of spaces, but with `;`s on the main diagonal.
```
v`( *;)( *)
$.1$2
```
Use the spaces before the `;` to generate the numbers from `n` down to `1` on the `n`th row, spaced using the spaces after the `;`.
```
P`.+
%`^.
$^$<'
```
Reflect horizontally.
```
L$`9
$>`$^$`
```
Reflect vertically (actually around the central `9` but it comes to the same thing).
92 bytes in [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d):
```
9$* 
 
$`;$'¶
(?=( *;)( *)).
$.1$2
.+
$&12$* 
(.(.{20})).*
$2$1
%20O^$`.
¶.+¶$
$&$`
9>O^$`
```
[Try it online!](https://tio.run/##FYqxDYQwEATzrcLBAraRTvgyhIAS6ACZgIDkgxfZ69tyAW7MmGSCmfme9/U5SsFIb2DAOLHLCXadrfGTq3BOQAlUSA@2Qd/TipWfDv8aPagMaHTYdkYBcpI@J9aXEePy2lIe "Retina 0.8.2 – Try It Online") Explanation:
```
9$* 
```
Insert 9 spaces.
```
 
$`;$'¶
```
Generate a `9×9` square of spaces, but with `;`s on the main diagonal.
```
(?=( *;)( *)).
$.1$2
```
Use the spaces before the `;` to generate the numbers from `n` down to `1` on the `n`th row, spaced using the spaces after the `;`.
```
.+
$&12$* 
(.(.{20})).*
$2$1
%20O^$`.
```
Reflect horizontally by prefixing each line with a copy of the 20 characters after the first and then reversing those 20 characters.
```
¶.+¶$
$&$`
9>O^$`
```
Reflect vertically by duplicating all the lines except the last and then reversing only the duplicates.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 21 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
9Lûε65S-Pð×yLûy9αð×ý«
```
[Try it online!](https://tio.run/##yy9OTMpM/f/f0ufw7nNbzUyDdQMObzg8vRLIrbQ8txHEPrz30Or/tYd2/wcA "05AB1E – Try It Online")
Port of my Thunno 2 answer. Unfortunately 05AB1E doesn't have the "push n spaces" built-in that Thunno 2 and Vyxal have.
Output as a list of lines. TIO footer joins by newlines.
*-2 thanks to @KevinCruijssen*
#### Explanation
```
9Lûε65S-Pð×yLûy9αð×ý«  # Implicit input
9Lûε                   # Map over [1,2,...,8,9,8,...,2,1]:
    65S-P×J            #  Push (n-6) * (n-5) spaces
           yLû         #  Push [1,2,...,n,...2,1]
              y9αð×ý   #  Join by (9-n) spaces
                    «  #  Prepend the leading spaces
                       # Implicit output
```
[Answer]
# [Zsh](https://www.zsh.org/), 108 bytes
```
for c ({1..9} {8..1}){w=$[(10**c/9)**2];printf \\n%$[(5-c)*(6-c)]s
for x (${(s::)w})printf %-$[9-$#w/2]s $x}
```
[Try it online!](https://tio.run/##qyrO@P8/Lb9IIVlBo9pQT8@yVqHaQk/PsFazutxWJVrD0EBLK1nfUlNLyyjWuqAoM68kTSEmJk8VKGWqm6yppWEGJGOLuUBGVChoqFRrFFtZaZbXakLVquqqRFvqqiiX6xvFFiuoVNT@/w8A)
Adapted from @Donat's "[bash diamond](https://codegolf.stackexchange.com/a/263045/15940)" code and my "[spaceship maw](https://codegolf.stackexchange.com/a/216255/15940)" solution.
[Answer]
# [J](http://jsoftware.com/), 45 bytes
```
8({.~#-@+41-:@-#)@dlb@(9&-":1+]-|@i:)@-|@i:@8
```
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/LTSq9eqUdR20TQx1rRx0lTUdUnKSHDQs1XSVrAy1Y3VrHDKtNB3AlIPFf02u1OSMfIU0dfX/AA "J – Try It Online")
Meh.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 98 bytes
```
j;main(z,x){for(;z<10;putchar(x>20?10:x%z|(x=58-z-abs(x/z))<49?32:x))x=j%43-21,z=abs(j++/43-8)+1;}
```
[Try it online!](https://tio.run/##FcntCoMgFADQpwnuRSW1Bi1zPosT9iFsjVZwubVnt/bzcJK6p1RKdq/4fANLwvU2TuB4MNp9ljk94gR0sToY3VPFG5A/dYpVvH6BakYc2nNobE@I5HPVNsoayf7fWYj6cIfCuF8pOw "C (gcc) – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 98 bytes
```
i,c=8;main(j){for(;--i/j?i=j=9-abs(c--):1;)printf("%*c",i-j?j-10:11*i-i*i-31,i-j?48+j-abs(i):10);}
```
[Try it online!](https://tio.run/##HcvBCoMwEEXRfxEKifWhQ11oQvBb7IDlDWhF3ZV@exQXd3PhKD6qObPS1MV55OLM/6bv5iLA2gYmSz3G9@4U8EGiXzcux@SKR6lFRdhgkCaIlASvXnLPtnvazXihxsd/zic "C (gcc) – Try It Online")
[Answer]
# [JavaScript (V8)](https://v8.dev/), 98 bytes
I don't know if it's very polite to answer my own challenge, but here it is!
```
for(z of(z=9,s=(n=1,p="".padEnd(9-z))=>n<z?n+p+s(n+1,p)+p+n:z)())print("".padEnd((6-z)*(5-z))+s())
```
[Try it online!](https://tio.run/##RcsxDoMwDEbhqyCm3wSQGFoVhMvEQaIiJDoYK4kYfPmQTt3e8L6vv3z8hENTd71y3s8Aq84dxmMbGcJDq1zXvfptlQ1jZ0T8ltkWceoixJWBSspkBCINhyT8AZ5FNHj8XNmJcr4B "JavaScript (V8) – Try It Online")
---
This is the combined works of [*Donat*'s recent Javascript answer to the challenge "Print this diamond"](https://codegolf.stackexchange.com/a/263191/116582)  
and [*The Thonnu*'s formula](https://codegolf.stackexchange.com/a/263139/116582): **(n−6)(n−5) for the leading spaces**.  
  
[*@Donat*](https://codegolf.stackexchange.com/users/95987/donat), don't hesitate if you want to post this as your own answer, this is mostly your work after all :)
[Answer]
# Vyxal, 278 Bytes
```
»×ẏ∴⁺¢ɽƒ3∴ĿṘ€ȯLdd2)"lY∇λµ≠Ḟw⅛!ḋ₌₁ẊṘ?
‡₄¥D‹Ḣ€ɾȯḟǑLdẇm₁≤ɖ↵$hḭ«€X⇧0A2&/•p[₀‟₃5Ǔ≈Π>ḋṠßĠ-⋏↳ĖOUḃ`∑ß∨(V⋏⋎ṁ7Ż≥×h'D℅p×>¥D↲‛℅ddlʀɾ⌐D%₆₄⁋ŻṘġȧ₅ḣ'ɾp0Ḋ¢lǐ⟨6K⌊∵¶⟨Ḣ,g#;¬‛^4⟨β•qrṠg₅Þf⋎→__↑¢[ẏNcḟ≠H꘍C¼↔Π꘍∧≬ǏḭḞǔṄꜝ⌐ø₇µ`ʁȯ⁋√ÞVe↲ <†∧↔⊍n÷PḂė?ġ¦$₌$e⋎\]↵⇩ṁn€⋏+₀ǒ&Ċ⌐∩ṁṗ½VḃḞβ#WżL∵ṖðǓmẊOur,8‹»`1 
23456789`τ
```
Compressed number converted to custom string base.
[Try it online!](https://vyxal.pythonanywhere.com/?v=2#WyIiLCIiLCLCu8OX4bqP4oi04oG6wqLJvcaSM%20KItMS/4bmY4oKsyK9MZGQyKVwibFniiIfOu8K14omg4bied%20KFmyHhuIvigozigoHhuorhuZg/XG7igKHigoTCpUTigLnhuKLigqzJvsiv4bifx5FMZOG6h23igoHiiaTJluKGtSRo4bitwqvigqxY4oenMEEyJi/igKJwW%20KCgOKAn%20KCgzXHk%20KJiM6gPuG4i%20G5oMOfxKAt4ouP4oazxJZPVeG4g2DiiJHDn%20KIqChW4ouP4ouO4bmBN8W74omlw5doJ0TihIVww5c%20wqVE4oay4oCb4oSFZGRsyoDJvuKMkEQl4oKG4oKE4oGLxbvhuZjEocin4oKF4bijJ8m%20cDDhuIrComzHkOKfqDZL4oyK4oi1wrbin6jhuKIsZyM7wqzigJteNOKfqM6y4oCicXLhuaBn4oKFw55m4ouO4oaSX1/ihpHColvhuo9OY%20G4n%20KJoEjqmI1DwrzihpTOoOqYjeKIp%20KJrMeP4bit4biex5ThuYTqnJ3ijJDDuOKCh8K1YMqByK/igYviiJrDnlZl4oayIDzigKDiiKfihpTiio1uw7dQ4biCxJc/xKHCpiTigowkZeKLjlxcXeKGteKHqeG5gW7igqzii48r4oKAx5ImxIrijJDiiKnhuYHhuZfCvVbhuIPhuJ7OsiNXxbxM4oi14bmWw7DHk23huopPdXIsOOKAucK7YDEgXG4yMzQ1Njc4OWDPhCIsIiIsIiJd)
]