brainfuck, 32 bytes

,[[<]>[.>]++++++++++.,[>>]<[-]<]

Try it online!

The same loop is used for both halves of the pattern.

Explanation:

,             Take first input character as initial line

[             Until line to output is empty:

  [<]>        Move to beginning of line

  [.>]        Output all characters in line

  ++++++++++. Output newline

  ,           Input next character

  [>>]        Move two cells right if input character nonzero

  <[-]        Otherwise remove last character in line

  <           Move to new last character in line

]

JavaScript (ES6), 36 bytes

f=([c,...r],s=`

`)=>c?s+f(r,s+c)+s:s

Try it online!

Commented

f = (             // f is a recursive function taking:

                  //   the input string split into:

  [c,             //     c   = next character (may be undefined if we've reached the end)

      ...r],      //     r[] = array of remaining characters

  s = `n`        //   the output string s, initialized to a linefeed

) =>              // 

  c ?             // if c is defined:

    s +           //   append s (top of the ASCII art)

    f(r, s + c) + //   append the result of a recursive call to f, using r[] and s + c

    s             //   append s again (bottom of the ASCII art)

  :               // else:

    s             //   append s just once (this is the final middle row) and stop recursion

05AB1E (legacy),  4  3 bytes

^{Crossed out  4  is no longer 4 :)}

η.∊

Try it online or verify all test cases.

Explanation:

η     # Get the prefixes of the (implicit) input-string

 .∊   # Vertically mirror everything with the last line overlapping

      # (which implicitly joins by newlines in the legacy version of 05AB1E)

      # (and output the result implicitly)

In the new version of 05AB1E, and explicit » is required after the η, which is why I use the legacy version of 05AB1E here to save a byte.

Python 2, 60 52 bytes

f=lambda s,n=1:s[n:]and[s[:n]]+f(s,n+1)+[s[:n]]or[s]

Try it online!

Python 3.8 (pre-release), 50 bytes

f=lambda s,n=1:s>(x:=s[:n])and[x,*f(s,n+1),x]or[s]

Try it online!

J, 11 bytes

Anonymous tacit prefix function. Returns a space-padded character matrix.

[:(}:,|.)]

Try it online!

] the list of prefixes

[:(…) apply the following function to that list

 |. the reverse list

 , prepended with

 }: the curtailed (without last item) list

Perl 6, 31 bytes

{[~](@_)[0...@_-1...0]}o*.comb

Try it online!

Anonymous code block that takes a string and returns a list of lines.

MATL, 8 bytes

nZv"G@:)

Try it online!

Please like this post for the smiley :) in the code it took me a lot of time to make.

n  % Length of the input string

Zv % Symmetric range ([1 2 ... n ... 1])

"  % For each k in above range

G  % Push input

@: % Push [1 2 ... k]

)  % Index

Haskell, 57 bytes

import Data.List

unlines.((++)<*>tail.reverse).tail.inits

Japt -R, 4 bytes

å+ ê

Cumulative reduce on a string.

-1 byte thanks to @Shaggy

Try it online!

Perl 5 (-p), 26 bytes

s,.,$=$`.$/.$;"$`$&

",ge

TIO

Japt -R, 9 7 bytes

-2 bytes thanks to Shaggy

Êõ@¯XÃê

Try it online!

R, 79 65 62 58 bytes

write(substring(s<-scan(,""),1,c(1:(r=nchar(s)),r-1:r)),1)

Try it online!

-14 by Giuseppe's superior function knowledge

-3 with cleaner indexing

-4 thanks to Nick Kennedy and Giuseppe's move to scan and write

Avoiding loops (and substr) is nice.

Python 3.8 (pre-release), 48 bytes

lambda s,r='':(l:=[r:=r+c for c in s])+l[-2::-1]

Try it online!

Uses assignment expressions with := to accumulate a list of prefixes and then again to save the result to concatenate its reverse (without the first char).

Python 2, 51 bytes

f=lambda s,l=[]:s and f(s[:-1],[s]+l)or l+l[-2::-1]

Try it online!

We almost have the following nice 45-byte solution, but it has the original string twice and I don't see a short way to fix this.

f=lambda s,l=[]:s and f(s[:-1],[s]+l+[s])or l

Try it online!

Charcoal, 5 bytes

Ｇ^Ｌθθ

Try it online! Link is to verbose version of code. Explanation: Ｇ draws a filled polygon, ^ specifies that the sides are down right and down left (the polygon then automatically closes itself), Ｌθ specifies the length of those sides as being the length of the original input and the final θ specifies the fill string.

C# (Visual C# Interactive Compiler), 123 109 94 84 74 bytes

Assumes we can return a char array array (I believe we can, as a char array is a valid representation for a string and a string array is a valid representation for multiple lines)

a=>new int[a.Length*2-1].Select((b,i)=>a.SkipLast(Math.Abs(a.Length-i-1)))

Try it online!

PowerShell, 89 87 66 bytes

-2 bytes thanks to @AdmBorkBork

param($a)0..($d=$a.Length-1)|%{$b+=,-join$a[0..$_]};$b+$b[--$d..0]

Try it online!

It actually didn't work as specified before, sorry about that! I've edited it and also managed to shave some bytes off.

Jelly, 5 4 bytes

-1 byte thanks to @JonathanAllan!

¹ƤŒḄ

Try it online! I think this is my second Jelly answer? I don't know if this is optimal. I am more convinced of it being optimal. Returns an array of lines.

Explanation

¹ƤŒḄ     input: "Hi!"

¹Ƥ       prefixes of the input: [["H"], ["H", "i"], ["H", "i", "!"]]

  ŒḄ     bounce, using each array: [["H"], ["H", "i"], ["H", "i", "!"], ["H", "i"], ["H"]]

Another approach, proposed by @JonathanAllan, is ;ŒḄ, which cumulatively reduces () concatenation (;), which is another way to generate prefixes.

IBM PC DOS, 8088 assembly, 44 bytes

be80 00ad 8bd6 b409 488a f88a c8d0 e149 b324 3acf 7d02 

4e4e 4686 1ccd 2186 1c52 ba29 01cd 215a e2ea c30d 0a24

Unassembled:

    MOV  SI, 80H            ; point SI to DOS PSP

    LODSW                   ; load arg length into AL, advance SI to 82H

    MOV  DX, SI             ; save start of string pointer

    MOV  AH, 9              ; DOS API display string function

    DEC  AX                 ; remove leading space from string length

    MOV  BH, AL             ; save string len in BH (AL gets mangled by INT 21H,9)

    MOV  CL, AL             ; set up loop counter in CL

    SHL  CL, 1              ; number of lines = 2 * string length - 1

    DEC  CX

    MOV  BL, '$'            ; end of string marker

LINE_LOOP:

    CMP  CL, BH             ; if CL >= string length, ascend

    JGE  ASCEND

    DEC  SI                 ; descend by backing up two places (always increments)

    DEC  SI                 ; (this is fewer bytes than 'SUB SI, 2' or two branches)

ASCEND:

    INC  SI                 ; increment current string position

    XCHG BL, [SI]           ; swap current string byte with end of string delimiter

    INT  21H                ; write substring to console

    XCHG BL, [SI]           ; restore string byte

    PUSH DX                 ; save output string pointer

    MOV  DX, OFFSET CRLF    ; load CRLF string

    INT  21H                ; write to console

    POP  DX                 ; restore output string pointer

    LOOP LINE_LOOP          ; move to next line

    RET

CRLF DB 0DH,0AH,'$'

Explanation

Loop 2 * input length - 1 for each row. The DOS API's string display function (INT 21H,9) writes a $-terminated string to the screen, so each time through the loop the character after the last to be displayed is swapped with the end-of-string terminator.

The loop counter is compared with the string length, and if it's greater (meaning the ascending part of the output) the string/swap position is incremented, otherwise it's decremented (actually it's -1-1+1 which is fewer bytes than an if/else branching structure).

Standalone executable program, takes input string from command line.

Output

Download YT.COM

APL (Dyalog Unicode), 9 bytes^SBCS

Anonymous tacit prefix function. Returns list of strings.

(⊢,1↓⌽),

Try it online!

, the list of prefixes (lit, the cumulative concatenation)

(…) apply the following function to that list:

 ⌽ the reversed list

 1↓ drop the first item

 , prepend

 ⊢ the unmodified list

Ruby, 51 42 40 bytes

f=->s,i=1{s[i]?[t=s[0,i],*f[s,i+1],t]:s}

Try it online!

Thanks to Doorknob for -2 bytes.

JavaScript (Node.js), 90 bytes

This can probably be golfed alot more, Arnauld already has a way shorter one but I had fun atleast!

s=>{a=[];for(c=s.length-1;c--;)a[c]=s.slice(0,c+1);return[...a,s,...a.reverse()].join`n`}

Try it online!

Attache, 15 bytes

Bounce@Prefixes

Try it online!

Pretty simple. Bounces (appends reverse without center) the Prefixes of the input.

Alternatively, 21 bytes: Bounce@{_[0..0:~-#_]}, re-implementing prefix.

F# (.NET Core), 67 61 bytes

let l=s.Length

[1..l*2-1]|>Seq.map(fun i->s.[..l-abs(i-l)-1])

Try it online!

Input is a string and output is a seq<string>

Another solution could be let f(s:string)=for i=1 to s.Length*2-1 do printfn"%s"s.[..s.Length-abs(i-s.Length)-1] for 80ish bytes... I am not sure that it is worth looking into.

PowerShell, 46 bytes

($l=$args|% t*y|%{($s+=$_);++$i})+$l[$i..0]|gu

Try it online!

PowerShell, 42 bytes (YouTube special, dirty)

It is known that the maximum length of a comment on youtube is 10,000 characters. Ok, use this as the upper limit.

($l=$args|% t*y|%{($s+=$_)})+$l[1e4..0]|gu

Try it online!

C (gcc), 68 67 + 3 bytes

i,j,t;f(char*s){for(;j?--i:++i;puts(s),j+=!t,s[i]=t)t=s[i],s[i]=0;}

Try it online!

if you want reusable version, it is below.

i,j,t;f(char*s){for(j=0;j?--i:++i;puts(s),j+=!t,s[i]=t)t=s[i],s[i]=0;}

                    ^^^

Try it online!

J, 12 bytes

],[:}.@|.]

Try it online!

Still 1 byte longer than Adám's

K (oK), 12 11 bytes

-1 byte thanks to ngn

{x,1_|x}@,

Try it online!

Octave, 58 bytes

for k=1:(n=nnz(s=input(''))*2)-1

disp(s(1:min(k,n-k)))

end

Try it online!