V, 14 bytes

òYp$xhòjòÄ$xhh 

Try it online!

Explanation:

ò ò "Recursively: Yp " Yank the current line and paste it $ " Move to the end of the current line x " Delete one character h " Move One character to the right. " Because of the way loops work in V, this will throw an error if there " Is only one character on the current line. 

Now, the buffer looks like this:

0123456789 012345678 01234567 0123456 012345 01234 0123 012 01 0 

We just need to do the same thing in reverse for the next line:

j "Move down one line ò ò "Recursively (The second ò is implicit) Ä " Duplicate this line up $ " Move to the end of the current line x " Delete one character hh " Move two characters to the right. " Because of the way loops work in V, this will throw an error if there " Is only two characters on the current line. 

More interesting alternate solution:

òÄ$xhòç^/:m0 ddGp@qd 

Python,  93 90  87 bytes

lambda*s,d=1,j='\n'.join:j(j([x[:i+1]for i in range(d<0,len(x))][::(d:=-d)])for x in s) 

An unnamed function that accepts the two strings and returns a string.

Note: Produces a trialling newline when the second input is length one.

Try it online

Previous, recursive function

-3 thanks to movatica.

f=lambda a,b,r='',i=2:a and f(a[:-1],b,r+a+'\n')or(b[i-1:]and f(a,b,r+b[:i]+'\n',i+1)or r) 

Starts with the empty string r, adds a and a newline and removes the last character from a until a is empty then adds the required portions of b and a newline by keeping a counter, i, which starts at 2 until the length of b is exceeded, then returns r. Has a trailing newline.

Try it online

05AB1E, 9 bytes

.pRI.p¦«» 

Explanation

.pR # prefixes of first word I.p # prefixes of second word ¦ # remove first prefix « # concatenate » # join with newlines 

Try it online!

Retina, 50 41 26 bytes

Thanks to Martin Ender for saving 15(!) bytes.

M&!r`.+ Om`^.¶[^·]+|.+ A1` 

Takes input with the two strings separated by a newline:

Test Testing 

Try it online!

Explanation

M&!r`.+ 

The first line generates the "steps" of both words:

Testing Testin Testi Test Tes Te T Test Tes Te T 

M is for match mode, & considers overlapping matches, and ! prints the matches instead of the number of them. The reason it's reversed is the right-to-left option: the engine starts looking for matches at the end of the string and continues toward the beginning.

Om`^.¶[^·]+|.+ 

This gets everything in the right order: it sOrts all matches of the subsequent regex: A character on its own line and every character (including newlines) after it, which matches the whole second half as one chunk, or otherwise a line of characters, which matches each individual line. These matches are then sorted by code point, so the T followed by the newline goes first, followed by the lines, ascending by length.

A1` 

Now we just have that first character line on top so we use Antigrep mode to discard the first match of the default regex .+.

Old version

M&!r`.+ O`\G..+¶ s`(.*)¶.¶(.*) $2¶$1 ¶.$ 

Try this version online!

Explanation

The first line is the same, so see the explanation for that above.

O`\G..+¶ 

This reverses the lines of the first half (second input word). It actually sOrts the lines, and the regex limits the matches: it must be a line of two or more characters (..+) followed by a newline (¶) that begins where the last one left off (\G). In the above example, the single T in the middle doesn't match, so nothing after it can.

Te Tes Test Testi Testin Testing T Test Tes Te T 

Now we have the right two components, but in the wrong order.

s`(.*)¶.¶(.*) $2¶$1 

¶.¶ matches the lone T in the middle, which we don't need but separates the two parts. The two (.*) capture everything before and after, including newlines thanks to single-line mode. The two captures are substituted in the right order with a newline in between.

Now we're done, unless the input strings are one character long, in which case the input hasn't changed. To get rid of the duplicate, we replace ¶.$ (when the last line of the string a single character) with nothing.

Perl, 34 28 bytes

Includes +2 for -0n

Run with the strings on separate lines on STDIN:

perl -M5.010 -0n slow.pl Test Testing ^D 

slow.pl:

/(^..+| \K.+?)(?{say$&})^/ 

Let regex backtracking do the work...

C (gcc), 102 97 95 93 78 bytes

f(a,b)char*a;{for(;*a;)a[puts(a)-2]=0;for(a=b+1;*a++;)printf("%.*s\n",a-b,b);} 

Try it online!

The first loop overwrites the string with 0 bytes starting from the end, using puts() to print the string as well as to get its current length. The second uses printf()'s support for variable field widths. The code also relies heavily on C's lack of type safety.

Thanks to @homersimpson and @ceilingcat for each shaving off 2 bytes, and @jdt for another whopping 15 bytes!

Python 2, 88 82 bytes

x,y=input(),input() for i in x:print x;x=x[:-1] s=y[0] for i in y[1:]:s+=i;print s 

Takes two inputs, each surrounded by quotes.

Thanks @JonathanAllan for saving some bytes and pointing out a bug.

Python 3, 104 bytes

Meh.

n='\n';lambda x,y:x+n+n.join(x[:-i]for i in range(1,len(x)-1))+n+n.join(y[:i]for i in range(1,len(y)+1)) 

Thanks to @DJMcMayhem for golfing 21 bytes off.

Ideone it!

Cheddar, 76 bytes

(a,b,q=s->(|>s.len).map((_,i)->s.head(i+1)))->(q(a).rev+q(b).slice(1)).vfuse 

A bit longer than I'd liked. I'll add an explanation soon

Try it online!

Brachylog, 32 bytes

:1aLtT,Lhbr:Tc~@nw :2fb ~c[A:B]h 

Try it online!

Explanation

Brachylog has no prefix built-in, therefore we will get the prefixes by using concatenate (See predicate 2): a prefix of S is P if P concatenated to Q (whatever it is) results in S.

• Main predicate:

  :1aL L is all prefixes of both elements of the input (see predicate 1) LtT, T is the second element of L Lhbr Remove the first prefix of the first list of L and reverse it :Tc Concatenate with T ~@n Join with newlines w Write to STDOUT 

• Predicate 1:

  :2f Find all prefixes of the input string (see predicate 2) b Remove the first one (empty string) 

• Predicate 2:

  ~c[A:B] Input is the result of concatenating A to B h Output is A 

Javascript, 103 81 bytes

f=(x,y,n=1)=>x?` `+x+f(x.slice(0,-1),y):n++<y.length?` `+y.slice(0,n)+f(x,y,n):'' 

Example: f("Test", "Testing")

Output:

Test Tes Te T Te Tes Test Testi Testin Testing 

Original answer

f=(x,y,n=1)=>x?(console.log(x),f(x.slice(0,-1),y)):n++<y.length?(console.log(y.slice(0,n)),f(x,y,n)):'' 

Java, 188 179 bytes

interface E{static void main(String[]a){int i=a[0].length();while(i>1)System.out.println(a[0].substring(0,i--));while(i<=a[1].length())System.out.println(a[1].substring(0,i++));}} 

Update

• Removed s variable, saved 9 bytes

Ungolfed:

interface E { static void main(String[] a) { int i = a[0].length(); while (i > 1) { System.out.println(a[0].substring(0, i--)); } while (i <= a[1].length()) { System.out.println(a[1].substring(0, i++)); } } } 

Usage:

$ java E 'test' 'testing' test tes te t te tes test testi testin testing 

Haskell, 54 53 47 bytes

t[]=[] t x=x:t(init x) (.reverse.t).(++).init.t 

Usage example: ((.reverse.t).(++).init.t) "Hello" "Hi!" -> ["Hello","Hell","Hel","He","H","Hi","Hi!"].

Some pointfree magic. It's the same as f x y = (init(t x))++reverse (t y) where t makes a list of all initial substrings e.g. t "HI!" -> ["H","HI","HI!"].

Pyke, 14 bytes

VDO)KKQlFh<)_X 

Try it here!

And 17 bytes just because it's an awesome solution:

mVDO)Fto!I_O(RKsX 

Try it here!

GNU sed, 57 45 + 2(rn flags) = 47 bytes

:;1{/../p};2G;2h;s/.(\n.*)?$//;/./t;g;s/.$//p 

Run:

echo -e "Test\nTesting" | sed -rnf morphing_string.sed 

The input should be the two strings separated by a newline. The code is run by sed for each line.

The loop : deletes one character from the end of the string iteratively. The output related to the first string is printed directly, except the first character: 1{/../p}. The output for the second string is stored in hold space in reverse order (2G;2h) during deletion and printed at the end.

Canvas, 8 bytes

［］↕ｋ；［］∔ 

Try it here!

[]↕k;[]+ | Full program (characters replaced for clean formatting) ---------+-------------------------------------------------------- [] | Prefixes of first input ↕ | Reversed k | Remove the last item ; | Swap (places the second input on top) [] | Prefixes of second input + | Add vertically 

REPL/Javascript, 109 Bytes

Uses false string to whittle down the original string

Abuses substring with larger numbers to grow the second one, stops when its about to print the same word as last time.

(a,b)=>{l=console.log;z='substring';for(c=a.length;d=a[z](0,c--);){l(d)}for(c=2;d!=(n=b[z](0,c++));){l(d=n)}} 

Demo:

> ((a,b)=>{l=console.log;z='substring';for(c=a.length;d=a[z](0,c--);){l(d)}for(c=2;d!=(n=b[z](0,c++));){l(d=n)}})("asdf","abcd") [Log] asdf [Log] asd [Log] as [Log] a [Log] ab [Log] abc [Log] abcd 

JavaScript (ES6), 92 bytes

(s,t)=>s.replace(/./g,` $\`$&`).split` `.slice(2).reverse().join` `+t.replace(/./g,` $\`$&`) 

The replace statements build up a triangle of strings, which is exactly what's required for the second half of the output, however the first half needs to be reversed and the duplicate single-character line removed. Note: outputs a leading newline if the first string is a single character. If this is undesirable then for an extra byte this version always outputs a trailing newline:

(s,t)=>s.replace(/./g,` $\`$&\n`).split(/^/m).slice(1).reverse().join``+t.replace(/./g,` $\`$&\n`) 

Brainfuck, 38 55 bytes

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

Edit: included newlines in output

Dyalog APL, 20 13 bytes

↑(⌽,\⍞),1↓,\⍞ 

↑ matrify

(⌽,\⍞) reversed (⌽) cumulative concatenation (,\) of character input (⍞)

, prepended to

1↓ one element dropped from

,\⍞ cumulative concatenation of character input

TryAPL online!

Racket 193 bytes

(define(f l) (let*((s(list-ref l 0)) (x(string-length s))) (for((n x)) (println(substring s 0(- x n)))) (set! s(list-ref l 1)) (for((n(range 1(string-length s)))) (println(substring s 0(add1 n)))))) 

Testing:

(f(list "Test" "Testing")) "Test" "Tes" "Te" "T" "Te" "Tes" "Test" "Testi" "Testin" "Testing" (f(list "Hello!" "Hi.")) "Hello!" "Hello" "Hell" "Hel" "He" "H" "Hi" "Hi." 

Floroid, 69 bytes

a,b=L.J c=1 NZ(a)!=1:z(a);a=a[:-1] z(a) NZ(a)!=Z(b):c+=1;a=b[:c];z(a) 

It's a start. Takes the input from STDIN.

Testcases

Input: Test Testing Output: Test Tes Te T Te Tes Test Testi Testin Testing Input: O O Output: O 

Husk, 7 bytes

+↔ḣ²tḣ⁰ 

Try it online!

Raku (Perl 6) (rakudo), 56 bytes

{join "\n",reverse([\~] $^a.comb),([\~] $^b.comb)[1..*]} 

Attempt This Online!

Thunno 2 N, 6 bytes

ƒr$ƒḣḥ 

Try it online!

Thanks to @Shaggy for pointing out a bug in the previous solution.

Explanation

ƒr$ƒḣḥ # Implicit input ƒ # Prefixes of first input r # Reverse the list $ƒ # Prefixes of second input ḣ # Remove first item ḥ # Concatenate the two lists # Implicit output, # joined on newlines (N flag) 

K (ngn/k), 14 bytes

{(|1_,\x),,\y} 

Try it online!

• ,\y generate prefixes of second input
• (|1_,\x) generate prefixes of first input, ignoring the first, and then reverse them
• (...),... concatenate them (and implicitly return)

Java, 152 143 142 bytes

Starting with the initial java-solution by Master_ex i improved it by merging the two loops into one:

interface E{static void main(String[]a){for(int i=a[0].length();--i>-a[1].length();)System.out.println(a[i<0?1:0].substring(0,i>0?i+1:1-i));}}

and readable

interface E { static void main(final String[] a) { for (int i = a[0].length();--i>-a[1].length();) System.out.println(a[i < 0 ? 1 : 0].substring(0, i > 0 ? i + 1 : 1 - i)); } } 

I am actually not sure, if the indexing is already optiomal, as some "- 1 / + 1" calculations are involved. Possible this can be writen better

Try it here

C, 142 bytes

#define _(x,y) while(y)printf("%.*s\n",d,x-c); f(char*a,char*b){int c=1,d=strlen(a)+1;while(*++a==*++b)c++;_(a,--d>=c)d++;_(b,d++<strlen(b-c))} 

Provide f(char* str1, char* str2).

TI-Basic, 56 bytes

Prompt Str1,Str2 Str1 While 1<length(Ans Disp Ans sub(Ans,1,length(Ans)-1 End For(I,1,length(Str2 Disp sub(Str2,1,I End 

Example usage

Str1=?Test Str2=?Testing Test Tes Te T Te Tes Test Testi Testin Testing Str1=?O Str2=?O O Str1=?z Str2=?zz z zz