[Question]
  [
Continuing my [*It was just a bug*](https://codegolf.stackexchange.com/questions/129523/it-was-just-a-bug) challenge:
### Input:
A string consisting of printable ASCII characters without white-spaces nor new-lines.
### Output:
First turn the input into a palindrome by reverting the input, and adding it before itself, excluding the middle character (i.e. with an input `1234567890`, it will becomes `0987654321234567890`).
And then output this text:
```
0        9        8        7        6        5        4        3        2        1        2        3        4        5        6        7        8        9        0
         0       9       8       7       6       5       4       3       2       1       2       3       4       5       6       7       8       9       0
                  0      9      8      7      6      5      4      3      2      1      2      3      4      5      6      7      8      9      0
                           0     9     8     7     6     5     4     3     2     1     2     3     4     5     6     7     8     9     0
                                    0    9    8    7    6    5    4    3    2    1    2    3    4    5    6    7    8    9    0
                                             0   9   8   7   6   5   4   3   2   1   2   3   4   5   6   7   8   9   0
                                                      0  9  8  7  6  5  4  3  2  1  2  3  4  5  6  7  8  9  0
                                                               0 9 8 7 6 5 4 3 2 1 2 3 4 5 6 7 8 9 0
                                                                        0987654321234567890
                                                               0 9 8 7 6 5 4 3 2 1 2 3 4 5 6 7 8 9 0
                                                      0  9  8  7  6  5  4  3  2  1  2  3  4  5  6  7  8  9  0
                                             0   9   8   7   6   5   4   3   2   1   2   3   4   5   6   7   8   9   0
                                    0    9    8    7    6    5    4    3    2    1    2    3    4    5    6    7    8    9    0
                           0     9     8     7     6     5     4     3     2     1     2     3     4     5     6     7     8     9     0
                  0      9      8      7      6      5      4      3      2      1      2      3      4      5      6      7      8      9      0
         0       9       8       7       6       5       4       3       2       1       2       3       4       5       6       7       8       9       0
0        9        8        7        6        5        4        3        2        1        2        3        4        5        6        7        8        9        0
```
(From the middle outward in both directions, each character is separated by one more space than the previous line.)
## Challenge rules:
* You need to print twice the length of the input, minus 3 lines. So with the input `1234567890`, the output displayed above is 17 lines (length 10 \* 2 - 3).
* The input will only contain printable ASCII (excluding space, tab and new-line).
* Trailing spaces are optional.
* A single trailing new-line is optional.
* (Additional) leading spaces or leading new-lines are not allowed.
* You can assume the input will always be at least four characters long.
* Unlike my *It was just a bug* challenge, both the input and output formats are flexible. So you are allowed to output the result as a String-array, String-list, etc.
## General rules:
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest answer in bytes wins.  
Don't let code-golf languages discourage you from posting answers with non-codegolfing languages. Try to come up with an as short as possible answer for 'any' programming language.
* [Standard rules apply](https://codegolf.meta.stackexchange.com/questions/2419/default-for-code-golf-program-function-or-snippet/2422#2422) for your answer, so you are allowed to use STDIN/STDOUT, functions/method with the proper parameters and return-type, full programs. Your call.
* [Default Loopholes](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) are forbidden.
* If possible, please add a link with a test for your code.
* Also, please add an explanation if necessary.
## Test cases:
```
Input: 1234567890
Output:
0        9        8        7        6        5        4        3        2        1        2        3        4        5        6        7        8        9        0
         0       9       8       7       6       5       4       3       2       1       2       3       4       5       6       7       8       9       0
                  0      9      8      7      6      5      4      3      2      1      2      3      4      5      6      7      8      9      0
                           0     9     8     7     6     5     4     3     2     1     2     3     4     5     6     7     8     9     0
                                    0    9    8    7    6    5    4    3    2    1    2    3    4    5    6    7    8    9    0
                                             0   9   8   7   6   5   4   3   2   1   2   3   4   5   6   7   8   9   0
                                                      0  9  8  7  6  5  4  3  2  1  2  3  4  5  6  7  8  9  0
                                                               0 9 8 7 6 5 4 3 2 1 2 3 4 5 6 7 8 9 0
                                                                        0987654321234567890
                                                               0 9 8 7 6 5 4 3 2 1 2 3 4 5 6 7 8 9 0
                                                      0  9  8  7  6  5  4  3  2  1  2  3  4  5  6  7  8  9  0
                                             0   9   8   7   6   5   4   3   2   1   2   3   4   5   6   7   8   9   0
                                    0    9    8    7    6    5    4    3    2    1    2    3    4    5    6    7    8    9    0
                           0     9     8     7     6     5     4     3     2     1     2     3     4     5     6     7     8     9     0
                  0      9      8      7      6      5      4      3      2      1      2      3      4      5      6      7      8      9      0
         0       9       8       7       6       5       4       3       2       1       2       3       4       5       6       7       8       9       0
0        9        8        7        6        5        4        3        2        1        2        3        4        5        6        7        8        9        0
Input: ABCD
Output:
D  C  B  A  B  C  D 
   D C B A B C D
      DCBABCD
   D C B A B C D
D  C  B  A  B  C  D
Input: =>)}]
Output:
]   }   )   >   =   >   )   }   ]
    ]  }  )  >  =  >  )  }  ]
        ] } ) > = > ) } ]
            ]})>=>)}]
        ] } ) > = > ) } ]
    ]  }  )  >  =  >  )  }  ]
]   }   )   >   =   >   )   }   ]
Input: XXxxXX
Output:
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  X  X  x  x  X  X
               X X x x X X X x x X X
                    XXxxXXXxxXX
               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   X   X   x   x   X   X
X    X    x    x    X    X    X    x    x    X   X
```
  
[Answer]
# [Japt](https://github.com/ETHproductions/japt), ~~22~~ 21 bytes
```
¬Å£¬qYîÃy w ê y w ê ·
```
[Test it online!](http://ethproductions.github.io/japt/?v=1.4.5&code=rMWjrHFZ7sN5IHcg6iB5IHcg6iC3&input=ImFiY2RlIg==)
### Explanation
The first 8 bytes generate the bottom-right quadrant of the pattern:
```
 ¬ Å  £    ¬ qYîÃ
Uq s1 mXY{Uq qYî} 
Uq                 : Split the input into characters.
   s1              : Slice off the first.
      mXY{      }  : Map each item X and index Y to
          Uq       :   the input split into chars,
             q     :   joined with
              Yî   :     Y spaces.
```
At this point we have an array of e.g. `["ABCD", "A B C D", "A B C D"]`. Unfortunately, it takes 13 bytes to square this:
```
y w ê y w ê ·
y w ê y w ê qR
y                : Pad each line to the same length with spaces and transpose.
  w              : Reverse the array, and
    ê            : palindromize. Now we have the bottom half of the output transposed.
      y          : Transpose back.
        w ê      : Reverse and palindromize again, giving the full output.
            qR   : Join with newlines.
                 : Implicit: output result of last expression
```
[Answer]
# [Python 3](https://docs.python.org/3/), ~~149 141~~ 95 bytes
```
def f(s):l=len(s)-1;[print((' '*abs(i)).join(s[:0:-1]+s).center(2*l*l+1))for i in range(1-l,l)]
```
[Try it online!](https://tio.run/##VYxLDoIwFAD3nKK7vgdCKPjFuPBziCaEBWirNS@FtCzw9LWJK3eTmWSmz/wabR3CQ2mmwWNDJ1I2Qi6O7eSMnQE442k/eDCIxXs0sbZN2eSiyzwWd2Vn5aBKKaVMIOrRMcOMZa63TwUipxVhFzTw8@V645j8pphEI@WySPnvRFWvN9vd/lByDF8 "Python 3 – Try It Online")
Thanks to @KevinCruijssen and @ETHproductions for saving some bytes
***Special thanks to @notjagan for saving 46 bytes!***
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 17 bytes
```
g<F¹RSðN×ýû})Rû.c
```
[Try it online!](https://tio.run/##ASsA1P8wNWFiMWX//2c8RsK5UlPDsE7Dl8O9w7t9KVLDuy5j//8xMjM0NTY3ODkw "05AB1E – Try It Online")
-1 thanks to [kalsowerus](https://codegolf.stackexchange.com/users/68910/kalsowerus).
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 14 bytes
```
Ｅ⁻Ｌθ¹⪫θ× ι‖Ｏ←↑
```
[Try it online!](https://tio.run/##ATkAxv9jaGFyY29hbP//77yl4oG777yszrjCueKqq864w5cgzrnigJbvvK/ihpDihpH//zEyMzQ1Njc4OTA "Charcoal – Try It Online")
AST:
```
Program
├Print
│└Ｅ: Map
│ ├⁻: Difference
│ │├Ｌ: Length
│ ││└θ: Identifier θ
│ │└1: Number 1
│ └⪫: Join
│  ├θ: Identifier θ
│  └×: Product
│   ├' ': String ' '
│   └ι: Identifier ι
└‖Ｏ: Reflect overlap
 └Multidirectional
  ├←: Left
  └↑: Up
```
[Answer]
# [JavaScript (ES6)](https://babeljs.io/), 159 136 129 127 bytes
```
f=(i,x=1-(l=i.length-1),y=x<0?-x:x,[,...b]=i)=>l>x?''.padEnd(l*(l+~y))+[...b.reverse(),...i].join(''.padEnd(y))+`
`+f(i,x+1):''
```
[Try it online!](https://tio.run/##bY1dC4IwGEbv@yPbm9vQvpOm9PUfhBDSnDYZm6jIvKi/bnkVhLfnnIenTLqkedSyammapEJRbTIxDDnHkljuUay4ZEroon1SD0jP7cENqfUtuRHGWBpzCTxQgQ0RYlWSXXWG1Rwr590DOLcxYbXoRN0IDONCxqw0UuNfPob32d3Jx0vHAx@h4WF0Y5RgyhQ4x8hbLFfrzXa3dxHA7E8eT@fLBOYBvOIJHkXWRtFXDB8 "JavaScript (ES6) – Try It Online") Explanation below
```
// This is a recursive function
// First, inputs and various variable initializations
// by using defaults
let func = (
  // Text input, will not be modified through recursion
  input,
  // Current line, for the first function call we start from -lines to +lines
  // It's roughly equivalent to lines*2 but this helps us computing the spacing
  // Also computing the total amount of lines
  currentLine = 1 - (totalLines = input.length - 1),
  // Getting the absolute value of the current line (like Math.floor)
  absCurrentLine = currentLine < 0 ? -currentLine : currentLine,
  // Getting the input without it's first letter, useful for the palidrome of the input
  [,...slicedInput] = input
// Base case, stopping the recursion if the current line
// is still below the total amount of lines
) => totalLines > currentLine
  // Leading spacing
  ? ''.padEnd(totalLines * (totalLines + ~absCurrentLine)) + 
  // Putting together the palindrome version and adding spaces between the chars
    [...slicedInput.reverse(), ...input].join(''.padEnd(absCurrentLine)) + `
  // Line return + recursion call
` + f(input, currentLine + 1)
  : ''
```
First entry to codegolf, I apologise in advance for any obvious mistakes.
Thanks to Justin Mariner for saving 23 bytes!
Thanks to Craig Ayre for saving 11 bytes and for the bug report.
[Answer]
# [SOGL V0.12](https://github.com/dzaima/SOGL), ~~22~~ 18 [bytes](https://github.com/dzaima/SOGL/blob/master/chartable.md)
```
ā,⁄H{,čFH@*∑Κ}▓±╬-
```
[Try it Here!](https://dzaima.github.io/SOGLOnline/?code=JXUwMTAxJTJDJXUyMDQ0SCU3QiUyQyV1MDEwREZIQColdTIyMTEldTAzOUElN0QldTI1OTMlQjEldTI1NkMt,inputs=JTNEJTNFJTI5JTdEJTVE)
Explanation:
```
ā                   push an empty array - canvas
 ,⁄H{        }      input length-1 times do
     ,                push the input
      č               chop it into chars
       FH@*           get the current iteration-1 amount of spaces
           ∑          join the chopped input with the spaces
            Κ         prepend it to the array
              ▓     space to a square
               ±    reverse each string in that list
                ╬-  quad-palindromize with 1 X and 1 Y overlap and without swapping characters
```
[Answer]
# PHP, ~~145~~ 131 bytes
It took some thinking to golf that additional byte; but it was worth it.
```
while($y<=2*$e=strlen($a=$argn)-1)echo($p=str_pad)("
",$e*($e-$d=abs($y++-$e))+1),chunk_split($a.substr(strrev($a),1),1,$p("",$d));
```
prints a leading newline. Run as pipe with `-nR` or [try it online](http://sandbox.onlinephpfunctions.com/code/5d070ffdde85d82aefcb56f98bb115c08b6a5db5).
**breakdown**
```
while($y<=2*$e=strlen($a=$argn)-1)  # $e=length-1, loop through rows
                                        # 1. print linebreak and left padding
    echo($p=str_pad)("\n",$e*($e-$d=abs($y++-$e))+1),
        chunk_split(
            $a.substr(strrev($a),1)     # 2. palindromize input
            ,1,$p("",$d));              # 3. insert $e..0..$e spaces between characters
```
**alternative solution**, same length:
```
for($d=-$e=strlen($a=$argn)-1;$d<$e;)echo($p=str_pad)("
",$e*($e-$b=abs($d++))+1),chunk_split($a.substr(strrev($a),1),1,$p("",$b));
```
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal) `C`, 11 bytes
```
ṪẏṘ∞ƛ?Ṙ∞$Ij
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyJDIiwiIiwi4bmq4bqP4bmY4oiexps/4bmY4oieJElqIiwiIiwiPT4pfV0iXQ==)
## Explanation
```
ṪẏṘ∞ƛ?Ṙ∞$Ij
Ṫ           # Remove the last element (removing the first element would be fine too)
 ẏ          # Make a range [0, length)
  Ṙ         # Reverse
   ∞        # Palindromize, a + a[::-1][1:]
    ƛ       # Map, and for each:
     ?Ṙ     #  Push the input reversed
       ∞    #  Palindromize that (call this X)
        $   #  Swap so the current item is at the top
         I  #  Push that many spaces
          j #  Join the characters of X by that
            # C flag centers and joins on newlines
```
[Answer]
# [APL (Dyalog)](https://www.dyalog.com/), 37 bytes
Requires `⎕IO←0` which is default on many systems.
```
{⍉m(2-d)↓⍉(m←⊖⍪1↓⊢)↑∊¨(1↓⍳d←≢⍵)↑¨¨⊂⍵}
```
`{`…`}` anonymous function where the argument is represented by *⍵*
 `(`…`)↑¨¨⊂⍵` for each (`¨`) of the following numbers take (`↑`) that many characters from each (`¨`) of the entire (`⊂`) argument, padding with spaces as necessary:
  `≢w` the number of characters in the argument
  `d←` store that in *d*
  `⍳` that many **ɩ**ndices (0 … *d* − 1)
  `1↓` drop one (the zero)
 `∊¨` **ϵ**nlist (flatten) each
 `↑` raise the rank (convert the list of lists into a matrix)
 `(m←`…`)` apply the following tacit function *m*, defined as:
  `⊖` the upside-down argument 
  `⍪` on top of
  `1` one [row]
  `↓` dropped from
  `⊢` the argument
 `⍉` transpose
 `(`…`)↓` drop:
  `2-d` = −(*d* − 2), i.e. *d* − 2 rows from the bottom
 `m` apply *m*
 `⍉` transpose
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qG@qp/@jtgkG/9OAZPWj3s5cDSPdFM1HbZOBbI1coOCjrmmPelcZgkS6FgElJj7q6Dq0QgMs0Ls5BaSic9Gj3q0gqUMrDq141NUE5NX@/5@moG5oZGxiamZuYWmgzgXkOjo5u4AZtnaatbFgVkRERUVEhDoA "APL (Dyalog Unicode) – Try It Online")
[Answer]
# [Java (OpenJDK 8)](http://openjdk.java.net/), ~~201~~ 196 bytes
```
s->{for(int l=s.length()-1,i=-l,x=0;++i<l;x+=i<0?l:-l)System.out.printf("%1$"+(x<1?"":x)+"s"+s.join("%1$"+(i<0?-i:i>0?i:"")+"s",(new StringBuffer(s.substring(1)).reverse()+s).split(""))+"%n","");}
```
[Try it online!](https://tio.run/##XVDLbsIwELzzFSurSLaSWKTvJgRUaI89cUQcQnDA1DiR14FUKN9OnYdUqT54VzOe8c4e03MaFKXQx933ray2SmaQqRQRvlKp4ToCGFC0qXXlXMgdnBxHV9ZIvV9vIDV7ZGAPprggfNaZKK0sei3A0X3AKysVzyudtQRfFhqrkzDT3mEGJrlhMLvmhaFSW1AJciX03h4oC0JfJoHy62QSe56cqrj2EjmdzFUUKLb6QStOvKgsL52VzSkZh3fEo/U0nBMS1cwjSDzkx8INPHCtOpCRnE3mMiKke@JTLS7Qz7Oo8lwYihyrLXYIDRnjRpyFQUGZh4xjqaSlTuzUY01818XNDboTd7nbML0fYAR/7uvNlYT3D49Pzy@vbxOnfF8sP1xJZqzZkIYNawMwPM3aVVJk8QD9j6s0HbhmNGqv5vYL "Java (OpenJDK 8) – Try It Online")
It's the same idea as [the one I used for the previous challenge](https://codegolf.stackexchange.com/a/129550/16236), except that the generator string is now a tad longer and with more hard to handle cases.
```
%1$Ns0%1$Ns9%1$Ns8%1$Ns7%1$Ns6%1$Ns5%1$Ns4%1$Ns3%1$Ns2%1$Ns1%1$Ns2%1$Ns3%1$Ns4%1$Ns5%1$Ns6%1$Ns7%1$Ns8%1$Ns9%1$Ns0%n
```
[Answer]
# [Python 3](https://docs.python.org/3/), ~~134~~ 124 bytes
```
f=lambda s:'\n'.join([' '*(len(s)-1)*abs(len(s)-abs(i)-2)+(' '*abs(i)).join(s[::-1]+s[1:]) for i in range(2-len(s),len(s)-1)])
```
[Try it online!](https://tio.run/##VYzLDoIwFET3fkV37QVrLPhsgomPj2iCXZQIWoMXQlngwm@vEiIJuzknM1O/20eFsfdFUppXdjPESXpFunhWFllKCQ1YmSNzwAUEJnN/6qMFHkHI@tKAMMxcKiUXOnSpkBpIUTXEEoukMXjPWcSHi/n4q8HXjcWWFYyKKF6tN9vdfkkBZqM@ns6XiUgO8NETo1TXKfVT/gs "Python 3 – Try It Online")
First post to PPCG after lurking for a while. Looking for any suggestions/advice!
---
Thanks to @LyricLy and @Łukasz Rogalski for improvements!
[Answer]
# Haskell, ~~177~~ 163 bytes
```
import Data.List
k n=[1..n]>>" "
f s=let n=length s in map(\x->(k(((n-1)*(n-(abs x)))))++(intercalate (k(abs x))$map(\z->[z])$((++)=<<reverse.tail) s))[n,n-1.. -n]
```
The function `f` is the challenge function and returns a list of strings (`[String]`), using `unlines` on it should provide the same visual output as the test cases (`main = putStr $ unlines $ f "test string"` to compile it).
[Try it online!](https://tio.run/##LU27bsMwDNz9FYThgYproc6jbYDYU8duHR0PTMA0gmXWkJggyM@7apAbDoc78u5McWDv59mN029Q@CQl@@WiZgNI09XWSt@2OeTZCWLjWZPrWX70DBGcwEgT7m9ViwMiSlWbRWKkQ4Sb@UdZohPlcCRPypDOnlnx@LxXbXfvTYFYlqbZ7QJfOUS2Ss4biMZ08pJarYVK@iwbKU02MF30WwMUcBHvhGNSJ8jr5Wq9eXv/2L7m8/wH)
-14 bytes thanks to @nimi
[Answer]
# [Thunno 2](https://github.com/Thunno/Thunno2) `N`, 14 [bytes](https://github.com/Thunno/Thunno2/blob/main/docs/codepage.md)
```
ḣı$ṅṣj;ðƬrⱮṬrⱮ
```
[Try it online!](https://Not-Thonnu.github.io/run#aGVhZGVyPSZjb2RlPSVFMSVCOCVBMyVDNCVCMSUyNCVFMSVCOSU4NSVFMSVCOSVBM2olM0IlQzMlQjAlQzYlQUNyJUUyJUIxJUFFJUUxJUI5JUFDciVFMiVCMSVBRSZmb290ZXI9JmlucHV0PSUyMjEyMzQ1Njc4OTAlMjImZmxhZ3M9Tg==)
I have *absolutely* no idea why this works, but it does.
#### Explanation
```
ḣı$ṅṣj;ðƬrⱮṬrⱮ  # Implicit input
ḣı    ;         # len(input) - 1 times:
  $  j          #   Join the input by...
   ṅṣ           #   ...loop index spaces
       ðƬ       # Transpose with filler space
         rⱮ     # Reverse and palindromise
           Ṭ    # Tranpose it
            rⱮ  # Reverse and palindromise
                # Implicit output, joined on newlines
```
I did quite a bit of experimenting, producing a lot of buggy outputs. Here's my favourite:
```
                                                                        0987654321234567890                                                                        
                                                               0 9 8 7 6 5 4 3 2 1 2 3 4 5 6 7 8 9 0                                                               
                                                      0  9  8  7  6  5  4  3  2  1  2  3  4  5  6  7  8  9  0                                                      
                                             0   9   8   7   6   5   4   3   2   1   2   3   4   5   6   7   8   9   0                                             
                                    0    9    8    7    6    5    4    3    2    1    2    3    4    5    6    7    8    9    0                                    
                           0     9     8     7     6     5     4     3     2     1     2     3     4     5     6     7     8     9     0                           
                  0      9      8      7      6      5      4      3      2      1      2      3      4      5      6      7      8      9      0                  
         0       9       8       7       6       5       4       3       2       1       2       3       4       5       6       7       8       9       0         
0        9        8        7        6        5        4        3        2        1        2        3        4        5        6        7        8        9        0
         0       9       8       7       6       5       4       3       2       1       2       3       4       5       6       7       8       9       0         
                  0      9      8      7      6      5      4      3      2      1      2      3      4      5      6      7      8      9      0                  
                           0     9     8     7     6     5     4     3     2     1     2     3     4     5     6     7     8     9     0                           
                                    0    9    8    7    6    5    4    3    2    1    2    3    4    5    6    7    8    9    0                                    
                                             0   9   8   7   6   5   4   3   2   1   2   3   4   5   6   7   8   9   0                                             
                                                      0  9  8  7  6  5  4  3  2  1  2  3  4  5  6  7  8  9  0                                                      
                                                               0 9 8 7 6 5 4 3 2 1 2 3 4 5 6 7 8 9 0                                                               
                                                                        0987654321234567890                                                                        
```
[Answer]
# Mathematica, 141 bytes
```
Column[Join[Reverse@(s=Row/@Table[Riffle[Reverse@Rest@b~Join~b,""<>Table[" ",i]],{i,0,Length[b=Characters@#]-1}]),Rest@s],Alignment->Center]&
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-R`](https://codegolf.meta.stackexchange.com/a/14339/), 15 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
ÊÆÔ¬qXç)êÃÔÅê û
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LVI&code=ysbUrHFY5ynqw9TF6iD7&input=IkFCQ0Qi)
```
ÊÆÔ¬qXç)êÃÔÅê û     :Implicit input of string
Ê                   :Length
 Æ                  :Map each X in the range [0,length)
  Ô                 :  Reverse U
   ¬                :  Split
    q               :  Join with
     Xç             :    X spaces
       )            :  End join
        ê           :  Palindromise
         Ã          :End map
          Ô         :Reverse
           Å        :Slice off first element
            ê       :Palindromise
              û     :Centre pad each element with spaces to the length of the longest
                    :Implicit output joined with newlines
```
[Answer]
# [Julia 1.0](http://julialang.org/), ~~100~~ 90 bytes
```
s->(l=length(s)-2;[' '^(-~l*(l-j))*prod(s[abs(i)+1]*' '^j for i=~l:l+1) for j=abs.(-l:l)])
```
[Try it online!](https://tio.run/##RY3LDoIwFETX9isaNtwLllh8a@p3NCGYYAAtaQqhNWHFr9fiQndzJmcy3Vurik@@pYJ6y26ghW7M073AIsuvRUzjO7BZJ6BZh5gMY1@DLaqHBYUpL5NF6Gjbj1SJWV90yvFLnQhOBixUWKJ3jXXhoiCRlNMkZbQmEc@3u/3heDpvIlISsqwcVYYuLlkNozJOG3D4yxm0Af8MSBpT@w8 "Julia 1.0 – Try It Online")
-10 bytes thanks to @KevinCruijssen
[Answer]
# [Canvas](https://github.com/dzaima/Canvas), 14 [bytes](https://github.com/dzaima/Canvas/blob/master/files/chartable.md)
```
Ｌ╷ｒＨ ×⁸；＊∔｝↔↕┼
```
[Try it here!](https://dzaima.github.io/Canvas/?u=JXVGRjJDJXUyNTc3JXVGRjUyJXVGRjI4JTIwJUQ3JXUyMDc4JXVGRjFCJXVGRjBBJXUyMjE0JXVGRjVEJXUyMTk0JXUyMTk1JXUyNTND,i=QUJDRA__,v=8)
## Explanation
```
L|rH ×⁸;*∔}↔↕┼
L              length of input
 |r            decrement, make range [0..n-1]
   H           create an empty art object, start a loop with i
     ×         repeat space i times
      ⁸;       swap with the input
        *      join input with i spaces
         ∔     add to the bottom of the previous iteration
          }    close the loop
           ↔↕  mirror horizontally and vertically
             ┼ quad palindromize with 1 character overlap
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 14 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
¦ε\RðN×ýû}Rû.c
```
Input as a list of characters.
[Try it online](https://tio.run/##yy9OTMpM/f//0IpzW2OCDm/wOzz98N7Du2uDDu/WS/7/P1rJUUlHyQmInYHYRSkWAA) or [verify all test cases](https://tio.run/##yy9OTMpM/V@m5JlXUFpipaBkX6nDpeRfWgLh6VQGH1r5/9CKc1sPrQs6vMHv8PTDew/vrg06vFsv@b/OoW32/6OVHJ2cXZR0lGztNGtjgXREREVFRASQYWhkbGJqZm5hqRQLAA).
**14 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage) alternative:**
```
ā¨RjJíðδÜ€ûû.c
```
Also takes a list of characters as input.
[Try it online](https://tio.run/##yy9OTMpM/f//SOOhFVleh9ce3nBuy@E5j5rWHN4ddHi3XvL//9FKjko6Sk5A7AzELkqxAA) or [verify all test cases](https://tio.run/##yy9OTMpM/V@m5JlXUFpipaBkX6nDpeRfWgLh6VQGu/w/0nhoRVCW1@G1hzec23J4zqOmNYd3H96tl/xf59A2@//RSo5Ozi5KOkq2dpq1sUA6IqKiIiICyDA0MjYxNTO3sFSKBQA).
**Explanation:**
```
¦              # Remove the first item of the (implicit) input-list
               # (could have removed the last as alternative as well)
 ε             # Map over each character:
  \            #  Discard the character
   R           #  Reverse the (implicit) input-list
     N         #  Push the 0-based map-index
    ð ×        #  Repeat a space character that many times as string
       ý       #  Join the reversed input-list with this spaces-string as delimiter
        û      #  Palindromize the entire string
 }R            # After the map: reverse the resulting list
   û           # Palindromize this entire list
    .c         # And centralize it, which also implicitly joins by newlines
               # (after which the result is output implicitly)
ā              # Push a list in the range [1, (implicit) input-length]
 ¨             # Remove the last item to make the range [1, input-length)
  R            # Reverse the list to (input-length, 1]
   j           # Pad each character in the (implicit) input-list with leading spaces so
               # the string lengths become equal to the current integer
    J          # Join each inner list of strings together to a single string
     í         # Reverse each string
       δ       # Map over each string:
      ð Ü      #  And remove all trailing spaces
         €û    # Palindromize each string
           û   # Palindromize the entire list
            .c # And centralize it, which also implicitly joins by newlines
               # (after which the result is output implicitly)
```
[Answer]
# [Zsh](https://www.zsh.org/), ~~117~~ ~~113~~ ~~109~~ 112 bytes
```
b=`rev<<<$1`${1:1};j=$#1
for c ({$j..1} {2..$j}){printf %$[(j-1)*(j-c)]s
for x (${(s::)b})printf %-$c\s $x;echo}
```
[Try it online!](https://tio.run/##NcrBCsIwDADQu18RMEIrrBCPXfclKoyVjtmD03boNOTbowhe3um966Q6dH1JjxACUo9MnqTNHW5pM84FIhjG7BwJ8ME5zGL5Vi7XZYQdHk1uyO6/Rnuuv7@CQTbVezuI/ccG46kCrm2K0yyqen@msrw@)
 ~~[109b invalid](https://tio.run/##qyrO@P8/yTahKLXMxsZGxTBBpdrQyrDWOstWRdmQKy2/SCFZQaNaJUtPz7BWodpIT08lq1azoCgzryRNISYmT1UlWiNL11BTC0gma8YWq6mBtFQoaKhUaxRbWWkmwRWr6qokxxQrqFT8//@/sDy1qKQSAA)~~
 ~~[113b](https://tio.run/##PcpBDsIgEADAu6/YxG0DGoh7RfoSStKUtFEOVaHRKuHta7w45/nkC/PYDWl6WmuRBixkqJ5jhw73pMjv5luCAKJg1PpUoZDWGKu8p@uyztD3S4MuHkRUQfrctr@@gcAisjFy/MdGoQtH8hlwY@bHa0rr@ws)~~
 ~~[117b](https://tio.run/##LcvdCsIgGAbg865C2DvQwsF36vRKnDD2R3mwmo5aidduEJ0/zydeSxlMH@an1hrUI5Gi3HoDi4okudNyD2xkPEn4poHPIk0Gaaxkbh/htu4L67q1hvVn7uUkXPyNg3EkHpUSQxZ/V0vY6UIuMhy5lLK95rC/vw)~~
`b` is the palindrome; `j` is the length of input string `$1`. Iterate `c` over the range `{j..1..j}`. For each `c`, print a prefixed number of spaces. For every character `x` in `b`, print `x` with `c` spaces between each.
]