MATL, 9 bytes

2Y2"@X@Y"

Try it online!

Explanation

2Y2     % Push string 'abc...z'
"       % For each char in that string
  @     %   Push current char
  X@    %   Push iteration index (1-based)
  Y"    %   Run-length decoding: repeat char that many times
        % Implicit end. Implicit display

Bespoke, 234 bytes

when I compose volumes of many English letters
they go in steps,all in single-step advances
look!stairs,in alphabet sequence!is this literal?why,no
I use it,a figurative notion,in teaching someone
to step out to an opening,reaching it

Uses the uppercase alphabet, because PUT XX:SEXTET FOUR (for pushing 64) saves 3 bytes over PUT XX:DIGITNINE SEXTET (for pushing 96).

Raku (Perl 6) (rakudo), 32 bytes

$!=65;say chr($!++)x$_ for 1..26

Attempt This Online!

☾, 8 characters (25 bytes)

ₐ⟕𝘀↨ᴍ⨀

The singleton list with the alphabet then being joined by prepending spaces is all to get the lowercase alphabet with a space prepended with the right operator precedence to save a character (suggested by Ganer)

Pyth, 7 bytes

VG*=hZN

Try it online!

Z is a variable, which is initialized to 0. The code loops through the alphabet G and outputs each time a letter times Z assigned to Z+1. Translated into python this means approximately:

Z = 0
for N in ['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z']:
 Z+=1
 print(N*Z)

There are 3 more Pyth answers to this challenge: 8 bytes, 7 bytes and 9 bytes

Tcl, 62 bytes

time {puts [string repe [format %c [expr 96+[incr a]]] $a]} 26

Try it online!

AWK, 51 bytes

END{for(;i++<26;print)for(x=i;x--;)printf"%c",i+96}

Attempt This Online!

OpTeX, 53 bytes

\fornum97..122\do{\fornum97..#1\do{\char#1}\par}\bye

OpTeX is a modernized version of plain TeX. With the code above, the output is correct, but doesn't look good, as the generated document uses by default non mono-spaced font. It's better with \tt (typewriter font), but this adds 3 more bytes.

\tt\fornum97..122\do{\fornum97..#1\do{\char#1}\par}\bye

Pyth, 9 bytes

VlG*@GNhN

V          - Loop over (with variable N)
 lG        -           length of G='abc...' (range(26))
   *   hN  - N+1 times
    @GN    - Nth character of alphabet (G[N])

Try it online!

tinylisp 2, 34 bytes

(m(\(N)(repeat(+ N 96)N""))(1to 26

A full program that outputs a list of lines. Try It Online!

To format the lines nicely is 41 bytes:

(w(} ,(m(\(N)(repeat(+ N 96)N nl))(1to 26

Explanation

(m(\(N)(repeat(+ N 96)N""))(1to 26))
(m                                 ) ; Map
                           (1to 26)  ; to the numbers 1..26
  (\(N)                   )          ; this function:
              (+ N 96)               ;  Add 96 to N
       (repeat        N  )           ;  Repeat that value N times
                       ""            ;  as characters in a string

Swift 5.10, 65 bytes

(1...26).map{print({String.init}()(.init(format:"%c",$0+96),$0))}

I took a hint from macOSisthebestOS's answer, but chose to generate characters from ASCII code, rather than typing them all out.

Acc!!, 66 64 bytes

Count i while 27-i {
Count j while i-j {
Write 96+i
}
Write 10
}

Outputs with a leading and trailing newline. Try it online!

With comments

# Loop i from 0 to 26
Count i while 27-i {
    # Loop j from 0 to i (exclusive)
    Count j while i-j {
        # Print the i'th letter (1-indexed)
        Write 96+i
    }
    # Print a newline
    Write 10
}

Excel, 33 bytes

=REPT(CHAR(ROW(65:90)),ROW(1:26))

Vyxal j, 3 bytes

nÞż

Try it Online!

Uiua, 10 bytes

⊜□⟜+⊚⇡27@`

Try it. Output as a list of lines.

Explanation:

⊚⇡27

The list [1,2,2,3,3,3,4,…,27,…,27]

⟜+ … @`

Add ` (character before a) to each on a copy.

⊜□

Partition into chunks of the same number (and thus same character), and box each so they can all be in an array together.

Swift 5.9, 79 bytes

zip("abcdefghijklmnopqrstuvwxyz",1...26).map{print({String.init}()($0.0,$0.1))}

While it is possible to create a range over the alphabet using "a"..."z", we can't actually iterate over this range. This is because, while Character does conform to Comparable (which is all we need to create the range), it doesn't conform to Strideable, which is needed to iterate over the range; and so, by extension, ClosedRange<Character> doesn't conform to Sequence, which is needed for for-in loops (and methods like map(_:)). Blame Swift's Unicode support, which seriously complicates the concept of "stride" for characters.

What all this means is that the shortest way of writing the alphabet in Swift (that I know of) is to just... write the alphabet.

YASEPL, 24 bytes

=i`1+=a$i+96»;a,i<!}2,26

Vyxal 3 j, 4 bytes

nfÞκ

Try it Online!

Fig, \$7\log_{256}(96)\approx\$ 5.762 bytes

*fcaa26

Try it online!

-2 chars thanks to my clone

*fcaa26 # Returns a list of lines, as allowed in the comments
 fca    # Split the letters of the alphabet
*       # Multiply
    a26 # By the range [1, 26]

Zsh (+ coreutils), 30 bytes

eval ';s+=_&&tr<<<$s _ '{a..z}

Attempt This Online!

Pure Zsh, 31 bytes

eval '<<<${(l:++i::'{a..z}:')}'

Attempt This Online!

K (ngn/k), 21 bytes

{{x#(`c$96+x)}'1+!26}

Try it online!

Explanation:

{{x#(`c$96+x)}'1+!26}      Main program
              '1+!26       For each number in range [1..26] (x) (inclusive)
 {           }             Execute a function that
    (`c$96+x)              Display the character with the ASCII code 96 + x
  x#                       x amount of times

Vyxal j, 6 bytes

ka¨2›*

Try it Online!

How?

ka¨2›*
ka     # Push the lowercase alphabet
  ¨2   # Map with indices (pushes letter and index)
    ›  # Increment the index to make it one-indexed
     * # Repeat the letter that many times

Also 6 bytes:

kaf:ż*

Try it Online!

How?

kaf:ż*
ka     # Push the lowercase alphabet
  f    # Convert to list of characters
   :   # Duplicate it
    ż  # Push length range [0, length)
     * # Repeat each letter that many times

Pyramid Scheme, 965 bytes

    ^
   / \
  /do \
 ^-----^
/!\    -^
---^    -^
  /=\    -^
 ^---^    -^
/a\ / \    -^
---/26 \   /[\
   -----  ^---^
         ^-  /[\
        ^-  ^---^
       ^-  / \  -^
      ^-  /set\  -^
     ^-  ^-----^  -^
    / \ /b\   /a\  -^
   /set\---   ---  /[\
  ^-----^         ^---^
 /a\   /+\       / \  -^
 ---  ^---^     /do \  -^
     /a\ /1\   ^-----^  -^
     --- ---  /b\   /[\  -^
              ---  ^---^  -^
                  / \  -^  -^
                 /set\  -^  -^
                ^-----^  -^  -^
               /b\   /-\  -^  -^
               ---  ^---^  -^  -^
                   /b\ /1\ / \  -^
                   --- ---/out\ / \
                         ^-----/out\ 
                        / \   ^-----
                       /chr\ / \
                      ^-----/chr\
                     /+\    -----^
                    ^---^       / \
                   /a\ / \     /10 \
                   ---/96 \    -----
                      -----

Try it online!

Wow this thing is huge. Nested loops result in a very big program.

tinylisp, 63 62 bytes

(load library
(map string(map* repeat-val(range 97 123)(1to 26

Try it online!

Output as a list of lines.

APOL, 14 bytes

ⅎ(ⓛ p(*(∋ ∈)))

Explanation:

ⅎ(        1-indexed for (f is 0-indexed)
  ⓛ      The built-in lowercase ascii letters constant
  p(      Print
    *(    Multiply
      ∋   Current item in the for loop
      ∈   For loop counter
    )
  )
)

Factor + spelling, 44 bytes

[ ALPHABET [ 1 + swap <string> ] map-index ]

Only works in recent-ish builds of Factor, so have a screenshot instead of a TIO link.

BQN, 11 bytes

⥊¨⟜'`'⊸+↕27

Run it online!

Outputs a list of lines, including an empty line at the beginning. If that's bending the rules too much, here's a 17-byte version that outputs a string (with two leading newlines).

Explanation

⥊¨⟜'`'⊸+↕27
         ↕27  Range(27)
    '`'⊸+     Add the ` character to each (0 -> `, 1 -> a, ..., 26 -> z)
⥊¨⟜          Reshape each: Nth character -> string N characters long

Python 2, 57 bytes

for a in "abcdefghijklmnosqrstuvwxyz":print a*(ord(a)-96)

Try it online!

Java (JDK), 68 bytes

n->{for(var i='`';i++<'z';)System.out.println((i+"").repeat(i-96));}

Try it online!

Forth (gforth), 49 bytes

: f 26. do i dup for dup 97 + emit next cr loop ;

Try it online!

Rockstar, 51 bytes

X's0
while X-26
build X up
cast X+96 into C
say C*X

Try it here (Code will need to be pasted in)

Labyrinth, 25 bytes

\#"_2@
;  -6
("##
. _
+59

Try it online!

Prints with one leading and one trailing newline.

      Start at the top left, going East
\     Print a newline
#"    Push stack height (" is no-op)
_26-  Subtract 26; if negative, turn left (South); if zero, turn backwards (East)
62@   Zero case (after 26 loops): halt after a few dummy instructions
##    Negative case (after n loops): push stack height twice
      (n -- inner loop counter k, then n+1)
_95+  Add 95
.     Print as char
(     Decrement k; if positive, turn right (East); if zero, go straight (North)
"#_   Positive case: repeat inner loop
;     Zero case: remove k and repeat outer loop

Pyth, 9 8 bytes

m*dhxGdG

Try it online!

m*dhxGdG
m      G  Map through the alphabet, with current letter as variable 'd'
   hxGd   Index of d in alphabet, + 1
 *d       Repeat current letter ↑ that many times.

VUG*hN@GN

In English; utilizing G as a auto-initialised variable of the alphabet:
Loop through list of 0-25:
print (i++ * letter at index i)

Jelly, 7 6 5 bytes

Øax"J

Try it online!

-1 byte thanks to dylnan

Returns a list of lines

How it works

Øax"J - Main link. No arguments
Øa    - Lower case alphabet
  x"  - each character repeated...
    J - range(len) times (vectorises)

An alternative (which I prefer, but is longer):

ØaḊLСUZYṚ

Try it online!

Ahead, 28 bytes

Featuring trailing newline!

'a'zEr~@~kdW<
~:\N\0<~'a-k:l

Try it online!

Dart, 81 bytes

List.generate(26,(i)=>''.padRight(i+1,String.fromCharCode(i+97))).forEach(print);

Try it online!

brainfuck, 70 59 bytes

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

Try it online!

-<--[[<+>->----<]++>]<-<-<<
Sets the tape up as:
     254
     9    Newline (10-1)
     230' Loop counter (-26)
     114  
     65   Character (A)
     1    Repeat counter
[ Loop 26 times
   >>>[-<.>>+<]   Print the character repeat counter times while preserving the counter
   >[-<+>]        Restore counter
   <[+<]          Increment everything
   >->.->         Print a newline
]

Scala (39 bytes)

('a'to'z')map(n=>println(s"$n"*(n-96)))

Try it online

K4, 13 bytes

(1+!26)#'.Q.a

Output:

q)k)(1+!26)#'.Q.a
,"a"
"bb"
"ccc"
"dddd"
"eeeee"
"ffffff"
"ggggggg"
"hhhhhhhh"
"iiiiiiiii"
"jjjjjjjjjj"
"kkkkkkkkkkk"
"llllllllllll"
"mmmmmmmmmmmmm"
"nnnnnnnnnnnnnn"
"ooooooooooooooo"
"pppppppppppppppp"
"qqqqqqqqqqqqqqqqq"
"rrrrrrrrrrrrrrrrrr"
"sssssssssssssssssss"
"tttttttttttttttttttt"
"uuuuuuuuuuuuuuuuuuuuu"
"vvvvvvvvvvvvvvvvvvvvvv"
"wwwwwwwwwwwwwwwwwwwwwww"
"xxxxxxxxxxxxxxxxxxxxxxxx"
"yyyyyyyyyyyyyyyyyyyyyyyyy"
"zzzzzzzzzzzzzzzzzzzzzzzzzz"

Julia, 42 36 bytes

[println(l^(l-'`')) for l∈'a':'z']

R, 33 bytes

cat(strrep(letters,1:26),sep="
")

Try it online!

This challenge got bumped to main; I tried a strrep approach which was happily shorter than the other existing R answer.

Whitespace, 127 bytes

Because the syntax is entirely in whitespace characters, each character is prefixed with S, T, or L (for Space, Tab, and Linefeed, respectively).

S S S T	L
L
S S L
S L
S S L
S S S S T	T	S S S S S L
T	S S S L
S S T	L
S L
S T	L
S S S L
T	S S S T	L
T	S S T	S L
S L
T	S T	S L
S L
T	L
S L
T	L
L
S S T	S L
S L
L
S L
L
S S S T	S T	S L
T	L
S S S S S T	L
T	S S S S L
S S S S T	T	S T	T	L
T	S S T	L
T	T	L
L
L
L

Try the whitespace-only version online!

MBASIC, 42 bytes

1 FOR I=1 TO 26:PRINT STRING$(I,96+I):NEXT

sed, 82 bytes

s:^:a:
:A
p
y:abcdefghijklmnopqrstuvwxy:bcdefghijklmnopqrstuvwxyz:
s:.:&&:
/z/q
bA

Try it online!

Loop from a to z. The last line is printed implicitly, preceding lines are printed with a p.

Pepe, 49 bytes

rEeEEeeeeEREeEEEEeEEREEreeereeErEEEeErEEEEEeeERee

Try it online!

Explanation:

rEeEEeeeeE # Push A (r)
REeEEEEeEE # Push 91 (Z + 1) (R)
REE        # Start loop labeled 91
           # | All the following commands below operate on r
reee       # | Output whole stack of r
reeE       # | Output newline "\n"
rEEEeE     # | Duplicate char to end
rEEEEEeeE  # | Increment whole stack
Ree        # If r != 91, repeat loop

APL (Dyalog), 12 8 5 bytes ^SBCS

3 bytes saved thanks to @ngn

4 bytes saved thanks to @Adám

⍴⍨⌸⎕A

OP clarified uppercase letters are valid, as well as output as an array of strings.

Try it online!

How?

⌸ gives us every letter in the ⎕A lphabet with its indexes in it, handed into the function ⍴⍨ with the letter as left argument and the indexes as right argument.

⍴⍨ resha ⍴ es its right argument to the length supplied by its left one. ⍨ switches the left and right (therefore the symbol of it, looking like the face of someone reading this explanation).

Visual Basic .NET (Mono), 120 bytes

Another BASIC answer

Module M
Sub Main
Dim S,I,J
For I=1To 26
S=""
For J=1To I
S+=Chr(I+64)
Next
Console.WriteLine(S)
Next
End Sub
End Module

Try it online!

MY-BASIC, 59 bytes

Anonymous Function that takes no input and outputs to the console.

For I=1 To 26
For J=1 To I
Print Chr(I+64)
Next
Print;
Next

Try it online!

Yabasic, 49 bytes

A BASIC answer that takes no input and outputs to the console.

For I=1To 26
For J=1To I
?Chr$(I+64);
Next
?
Next

Try it online!

uBASIC, 57 bytes

Anonymous function that takes no input and outputs to the console.

0ForI=1To26:ForJ=1ToI:?Left$(Chr$(I+64),1);:NextJ:?:NextI

Try it online!

Kotlin, 76 bytes

for(i in 0..25){var j=0;while(j<=i){print((i+97).toChar());j++};print("\n")}

Try it online!

Excel VBA, 38 bytes

Using Immediate Window. :)

[A1:A26]="=REPT(CHAR(96+ROW()),ROW())"

SNOBOL4 (CSNOBOL4), 74 bytes

O	&LCASE POS(I) LEN(1) . X
	I =I + 1
	OUTPUT =LE(I,26) DUPL(X,I) :S(O)
END

Try it online!

O	&LCASE POS(I) LEN(1) . X		;* set X to I'th 0-indexed character of lowercase letters
	I =I + 1				;* increment I
	OUTPUT =LE(I,26) DUPL(X,I) :S(O)	;* if I<=26, output X DUPLicated I times and goto O otherwise goto END
END

JsFuck, 7929c

[][(![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]]+([![]]+[][[]])[+!![]+[+[]]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[!![]+!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(![]+[])[+!![]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]]([!![]]+[][[]]+[][[]]+!![])[(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+!![]]]([][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((![]+[])[+[]]+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]()[+!![]+[+!![]]]+(+!![])+(+[])+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]+(!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]]+[])[!![]+!![]+[+[]]]+[][[]]+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]()[+!![]+[+!![]]]+([]+[])[(![]+[])[!![]+!![]+!![]]+([][[]]+[])[+[]]+([][(!![]+[])[!![]+!![]+!![]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]]()+[])[!![]+!![]]]()[+!![]+[+[]]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(!![]+[])[!![]+!![]+!![]]+(+(+!![]+[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+!![])+(+[]))+[])[+!![]]+(![]+[])[!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(+[]+[![]]+([]+[])[([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]])[!![]+!![]+[+[]]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[!![]+!![]+!![]]]+(![]+[])[+[]]+(+(+!![]+[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+!![])+(+[]))+[])[+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([]+[])[([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]][([][[]]+[])[+!![]]+(![]+[])[+!![]]+([]+(+[])[([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]])[+!![]+[+!![]]]+(!![]+[])[!![]+!![]+!![]]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[!![]+!![]+!![]]]+(!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![])+(+[]+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]+(+(+!![]+[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+!![])+(+[]))+[])[+!![]]+(!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]]+[])[!![]+!![]+[+[]]]+([][(!![]+[])[!![]+!![]+!![]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]]()+[])[!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[+!![]])()([][[]]))[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[+!![]]+(!![]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[!![]+!![]+!![]]]+(+(+!![]+(!![]+[])[!![]+!![]+!![]]+(+!![])+(+[])+(+[]))+[])[!![]+!![]]+(+(+!![]+(!![]+[])[!![]+!![]+!![]]+(+!![])+(+[])+(+[]))+[])[!![]+!![]]+(![]+[])[+[]]+(+((+(+!![]+[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+!![])+(+[]))+[])[+!![]]+(+[])+(+[])+(+[])+(+[])+(+[])+(+[])+(+[])+(+[])+(+[])+(+!![]))+[])[!![]+!![]]+(+!![])+(+[])+(+[]+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]+(+[]+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]])())

From

[].slice.call('trueundefinedundefinedtrue').filter([].filter.constructor('f=10\nreturn undefined=>console.log(f.toString(36).repeat(++f-10))')())

JsFuck, 7961c

[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]([][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]]+[])[!![]+!![]+[+[]]]+([][[]]+[])[+[]]+([][[]]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(![]+[])[+!![]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]]+[])[!![]+!![]+[+[]]]+([][(!![]+[])[!![]+!![]+!![]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]]()+[])[!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[+!![]])()([][[]]))[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]])()(((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+![]+(!![]+!![])+(+[])+(![]+[])[+[]]+![]+(!![]+!![]+!![])+([][[]]+[])[!![]+!![]]+![]+(!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+(!![]+[])[+[]]+![]+(!![]+!![]+!![])+([][[]]+[])[!![]+!![]]+(+!![])+(+[])+![]+(!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![])+([][[]]+[])[!![]+!![]]+![]+(!![]+!![]+!![])+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+![]+(!![]+!![])+([][[]]+[])[!![]+!![]]+(!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![])+(![]+[])[+[]]+(!![]+[])[+[]]+![]+(!![]+!![])+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+![]+(!![]+!![]+!![]+!![]+!![]+!![])+(![]+[])[+[]]+![]+(!![]+!![]+!![]+!![]+!![])+(!![]+!![]+!![])+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+![]+(!![]+!![]+!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+(!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![])+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+![]+(!![]+!![]+!![]+!![]+!![]+!![]+!![])+(+[])+(!![]+[])[!![]+!![]+!![]]+(![]+[])[+!![]]+(!![]+[])[+[]]+![]+(!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+(+(+!![]+(!![]+[])[!![]+!![]+!![]]+(+!![])+(+[])+(+[]))+[])[!![]+!![]]+(+(+!![]+(!![]+[])[!![]+!![]+!![]]+(+!![])+(+[])+(+[]))+[])[!![]+!![]]+(!![]+[])[+[]]+![]+(!![]+!![])+([][[]]+[])[!![]+!![]]+(+!![])+(+[])+![]+(!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+(+(+!![]+(!![]+[])[!![]+!![]+!![]]+(+!![])+(+[])+(+[]))+[])[!![]+!![]]+![]+(!![]+!![]+!![]+!![]+!![]+!![])+(+[])+![]+(+[])+(![]+[])[+!![]]+![]+(!![]+!![]+!![]+!![]+!![]+!![])+(+[])+(+(+!![]+(!![]+[])[!![]+!![]+!![]]+(+!![])+(+[])+(+[]))+[])[!![]+!![]]+(![]+[])[+[]]+![]+(!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+(!![]+[])[+[]]+![]+(!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![])+(![]+[])[+!![]]+![]+(!![]+!![])+(!![]+!![])+![]+(!![]+!![])+(!![]+!![]))[(![]+[])[!![]+!![]+!![]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]]+[])[!![]+!![]+[+[]]]+([][(!![]+[])[!![]+!![]+!![]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]]()+[])[!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[+!![]])()([][[]]))[+!![]+[+[]]]+(![]+[])[!![]+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[+[]]](![])[([][(!![]+[])[!![]+!![]+!![]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]]()+[])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([![]]+[][[]])[+!![]+[+[]]]+([][[]]+[])[+!![]]]([][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]]+[])[!![]+!![]+[+[]]]+(![]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][(!![]+[])[!![]+!![]+!![]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]]()+[])[!![]+!![]])()(+[]+[+[]]+(+[])+(![]+[])[!![]+!![]])[!![]+!![]])))

From

[].filter.constructor(unescape('returnfalse20ffalse3dfalse28tfalse3d10false29false3dfalse3etfalse2d36false3ftfalse2etfalse6ffalse53trinfalse67false2836false29false2erefalse70eatfalse28++tfalse2d10false29+false60false0afalse60+ffalse28tfalse29false3afalse22false22'.split(false).join('%')))

Both work on Firefox, because I only have it

Japt, 9 7 bytes

Outputs an array of lines

;C¬Ëp°E

Try it

Explanation

Split (¬) the lowercase alphabet (;C) to an array of characters, map over the array (Ë) and repeat (p) the current element by the current index (E) incremented (°) times.

Kotlin, 37 bytes

{(1..26).map{"${'`'+it}".repeat(it)}}

Try it online!

Returns a List of Strings

Befunge 2x24 = 48 Bytes

I know the other befunge answer has me solidly beat, but I thought I'd post my solution anyway, as it's interesting, since it's partially self-modifying.

"z`"-:!_> 10g\v v!:_0# p
g01+55$_^#!:-1<@_,1^01-1

Try It Online

How it works

"?`"-:!

Gets how many times to iterate. (The question mark represents the current letter)

        _> 10g\v
        _^#!:-1<

Adds the iteration size*char into the stack.

                   _0# p
g01+55$_           ^01-1 

Pops the excess character and adds a newline. Gets the current character from 1,0 and decrements it, putting back at 1,0

"?`"-:!_           _0# p

Now the ? inside the quotes has been decremented. Once it has run through all the letters it runs backwards from the underscore, which was the tricky part. ! inverts the excess 0 to a 1, which is duplicated and subtracted from itself, turning it back to a 0. The 0 is put at (97,97) thanks to the backticks inside the quotes and the put command. This leaves just the original iteration size, which is 0, when it hits the underscore, pushing the pointer left.

                v!:_
               @_,1^

Prints out the whole stack, which at this point is a newline separated alphabet staircase.

Kotlin, 56 bytes

for(c in 'a'..'z'){for(j in 0..c-'a')print(c);println()}

Try it online!

Vim, 33 Keystrokes

:h<_␍jjYZZiyl0pr␛pqq{<C-a>YG@"q25@q{D

Explanation

:h<_␍jjYZZ                             " get a-z 
          iyl0pr                       " Put yl0pr as macro line 
                ␛p                     " Back to normal mode and paste
                  qq                   " Record macro
                    {                  " Go to macro line 
                     <C-a>             " Increment counter
                          Y            " Yank the macro
                           G           " Go to last line
                            @"         " Run the macro (also adds \r)
                              q        " Stop recording @q
                               25@q    " Run @q 25 times
                                   {D  " go to top and clear the line

Had experimented with this which inspired the above Macro line:

:h<_␍jjYZZP:exe ":norm yl".line('.')."ps^M"␍25@:

Thought about putting a-z on separate lines and global replace with repeat, but can't make :%s/./\=repeat(\0,line('.'))/g work -- and that's long.

Java (OpenJDK 8), 74 bytes

n->{for(int i=1,j=0;i<27;)System.out.printf("%c",j++<i?96+i:10+(j-=++i));}

Try it online!

6 bytes saved thanks to @KevinCruijssen

Explanations

n->{                      // Lambda, unused parameter
 for(int i=1,j=0;i<27;)   // Loop from 1 to 26 included
  System.out.printf("%c", // Print a character
   j++<i                  // Do we need to print a letter or a new line?
    ?96+i                 // It's a character, construct it.
    :10+(j-=++i)          // It's a new line, increment i and reset j to 0.
  );
}

Ruby, 38 bytes

Returns an Array of strings

->{(a=*?a..?z).map{|x|x*-~a.index(x)}}

-5 bytes thanks to totallyhuman

*-11 bytes thanks to some excellent golfing by Jordan.

Javascript (ES6) 61 bytes

_=>[...Array(26)].map((_,i)=>(10+i).toString(36).repeat(i+1))

Javascript (ES6) 62 bytes

_=>[..."abcdefghijklmnopqrstuvwxyz"].map((v,i)=>v.repeat(i+1))

I'm aware there's a better answer already for js, still wanted to post these, feel free to suggest any improvement as long as it keeps the "methodology" intact. (for readability im using underscores for unused variables)

Brainfuck, 107 104 94 Bytes

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

How it works:

>>>>++[<<<+++++++++++++>>++++[<++++++++>-]>>+++++<-]<<+>+

Stores 26 on the second cell, 65 on the third cell, 10 on the sixth cell, and 1 on the fourth, leaving the pointer on the fourth (Saved 3 13 bytes by making 26, 10, and 97 65 at the same time).

[<]>

Moves the pointer back to the start.

Now we're ready to get started!

[                       | While the first cell is non-zero (so 26 times)
>>                      | Move to cell 3
    [                   | While cell 3 is non-zero
        <.>>+<-         | Print cell 2, increment cell 4, and decrement cell 3
    ]                   |
    >>.<<               | Move to cell 5 and print it (new line), then return
    <+>+>               | Increment cells 2 and 3, and move to 4
    [<+>-]              | Add the value at 4 to 3
<<<-                    | Decrement cell 1
]                       |

The important part is that cell 3 stores the number of times to print a letter. Each time a letter is printed, the value at 3 is moved to 4 and increased by 1, so that the next number is printed one more time than the last.

Side Note:

I'm completely new to brainfuck, so I wouldn't be surprised if this could be improved. However, I was also surprised by how fun brainfuck is to write, as well as by how easy it was to write, when compared with what I had imagined.

I would definitely recommend learning brainfuck to any bored programmers out there ;)

F# (.NET Core), 58 bytes

58 bytes

[1..26]|>Seq.map(fun i->new System.String((char)(i+96),i))

Try it online!

A basic port of my C# answer.

59 bytes

[1..26]|>Seq.map(fun i->[1..i]|>Seq.map(fun _->i+96|>char))

Try it online!

Same answer as above but without `System.String.

Ruby, 28 31 35 bytes

Edit: saved 3 bytes by using a number range instead of letters. Try it online!

(0..26).map{|l|(l+96).chr*l}

Edit: saved 4 bytes by using the character number instead of looping with index. Try it online!

('`'..'z').map{|l|l*(l.ord-96)}

Edit: saved 6 bytes by outputting a list. Try it online!

('`'..'z').map.with_index{|l,i|l*i}

Original:

('`'..'z').each_with_index{|l,i|puts l*i}

Lua, 48 bytes

for i=1,26 do print(string.char(i+96):rep(i))end

Try it online!

Explanation:

1. for i=1,26 do ... end — try all numbers between 1 and 26.
2. print(...) — prints, of couse.
3. string.char(i+96) — get alphabet char number i.
4. :rep(i) — repeat char i times.

Check, 26 bytes

 >#v
#d##)::>96+]*o<:>26-?

Try it online!

Explanation:

Check's gimmick is that it can switch between 2D semantics (for control flow) and 1D semantics (for stack manipulation). The program starts out at the beginning of the program in 1D semantics.

> pushes 0 to the stack. # switches to 2D semantics and v directs the IP downwards. It then hits #, switching back to 1D semantics for the main loop.

#d##)::>96+]*o<:>26-?

The commands before the ? go like this:

#    1D mode:                   0
)    increment:                 1
:    duplicate:                 1, 1
:    duplicate:                 1, 1, 1
>96  push 96:                   1, 1, 1, 96
+    add:                       1, 1, 97
]    wrap:                      1, 1, [97]
*    repeat:                    1, [97]
o    output char codes ("a"):   1
<    output newline ("\n"):     1
:    duplicate:                 1, 1
>26  push 26:                   1, 1, 26
-    subtract:                  1, -25

The ? is Check's only branching operator. It switches to 2D semantics if the TOS is nonzero, and stays in 1D semantics otherwise. In this case, if the top stack value is 0, then the program ends, and if it is negative, then it goes around to the beginning. # switches back to 1D semantics, d deletes the top stack element (since ? does not pop it). ## switches to 2D and then back again, and then the loop restarts.

CJam, 13 bytes

26{)_96+c*N}%

Explanation:

26             e# push 26
  {        }%  e# for n in 0 .. 25:
   )           e#   increment
     96+       e#   add 96
        c      e#   convert to character
    _    *     e#   repeat that character n+1 times
          N    e#   add a newline

Pushy, 8 bytes

Z26:q&Kh

Try it online!

Z          \ Push 0 to the stack
 26:       \ 26 times do:
    q      \    Print stack, with each number as its letter in the 0-indexed lower alphabet
     &     \    Make a copy of the last number
      Kh   \    Increment all numbers

C# (.NET Core), 57 bytes

57 bytes with a a trailling line

()=>new int[27].Select((_,i)=>new string((char)(i+96),i))

59 bytes without a trailling line

()=>new int[26].Select((_,i)=>new string((char)(i+++97),i))

Try it online!

I am using using System.Linq;

• The int[x].Select() can be found here.

Brain-Flak, 107 bytes

((((()()()){}){}()){}){(({})){({}<(({})<({}((((()()()()){}){}){}){})>)>[()])}{}({}<((()()()()()){})>[()])}

Try it online!

This is 106 bytes of code, and +1 byte for the -A flag, which enables ASCII output.

Explanation:

#Push 26
((((()()()){}){}()){})

#While True...
{

    #Duplicate A
    (({}))

    #While True...
    {
        #Grab the value of A...
        ({}<

            #Make a duplicate of B (on the first loop, B == A)
            (({})<

                #Push B + 
                ({}

                #64 (ASCII 'A' - 1)
                ((((()()()()){}){}){}){})

            #Then push B on top of all of that
            >)

        #Push A - 1 on top of all of that
        >[()])

    #Endwhile, pop the loop counter
    }{}

    #Underneath A,
    ({}<

        #Push 10
        ((()()()()()){})

    # Then Push A - 1
    >[()])

#Endwhile
}

x86-64 machine code function, 19 bytes

18 bytes for x86-32 with a non-standard calling convention, inc eax is only 1B vs. 2B.

Callable from C (with the x86-64 System V calling convention) as:

void alphabet_staircase(char output[377]);

// or
struct string_result { char buf[377]; }  \
  alphabet_staircase(void);   // return-value pointer passed as implicit first arg

i.e. it stores a flat string (including '\n' newlines) into a buffer pointed to by rdi.

0000000000400080 <alphabet_staircase>:
  400080:       6a 61           push   0x61
  400082:       58              pop    rax      ; eax = 'a'

0000000000400083 <alphabet_staircase.loop>:
                                 ;;; do {
  400083:       8d 48 a1        lea    ecx,[rax-0x5f]      ; rax-'a'+1 + 1
  400086:       f3 aa           rep stos BYTE PTR es:[rdi],al
  400088:       c6 47 ff 0a     mov    BYTE PTR [rdi-0x1],0xa
  40008c:       ff c0           inc    eax
  40008e:       3c 7a           cmp    al,0x7a
  400090:       76 f1           jbe    400083 <alphabet_staircase.loop>
                                 ;;; } while(al <= 'z')
  400092:       c3              ret

  400093  end of function.  0x93 - 0x80 = 0x13 = 19 bytes

Try it online! (including a _start caller that prints the result with sys_write())

In each loop iteration, we store one extra copy of current letter, then overwrite it with a newline. rep stosb = memset(rdi, al, rcx). It advances rdi to point one-past-the-end of the bytes it stored.

eax holds the current letter, and we use it as the loop counter. do {} while(eax <= 'z');. Setting rcx from it with LEA requires that the upper bytes of eax be zeroed, otherwise we could use 2-byte mov al, 'a' to start.

The x86-64 SysV ABI requires that DF is cleared on function entry/exit, so we don't need cld. If we wanted to use std to store backwards, it wouldn't solve the problem of needing an offset of one in an addressing mode to store the newline (or needing a separate inc/dec, or swapping eax with a reg holding 0x10 and using stosb to store a newline); stosb always overwrites the memory rdi is pointing to.

Underload, 62 bytes

()(::(.)~^(.):*:*:*:*:*::***( )*~^S(
)S(:)~*(*)*):*::*:*::***^

Try it online!

This is really stretching the limits of what's allowed.

It outputs a list of lines represented by strings (allowed by the OP), where the strings are lists of bytes (allowed by meta consensus), where the bytes are given in unary (also allowed by meta consensus).

The result is... well, see for yourself.

Japt, 17 16 11 bytes

_{-5 bytes thanks to Oliver}

In ISO-8859-1

;26ÆCgX pXÄ

Not the best score, but I'm still a novice. Any suggestions are very welcome.

Outputs list of lines, as OP allowed. Link contains 3 bytes more for newlines.

Try it online!

;                      - Use string variables
 26                    - Literal 26
   Æ                   - For range 0..26
    C                  - Alphabet
     gX                -         . character at index X
        pXÄ            - Duplicate X+1 times
                       - End function (implicit)

C++, 56 bytes

for(char a='a';a<='z';++a)cout<<string(a-'a'+1,a)<<endl;

Try it online

C (gcc), 48 bytes 50 bytes

Re-runnable version, as per cleblanc and Steadybox in the comments below.

s[9];main(i){for(;i<27;)puts(memset(s,i+95,i++));}

Try it online!

C# (.NET Core), 84 bytes

()=>{return A(1);string A(int n)=>new string((char)(n+96),n)+(n<26?"\n"+A(++n):"");}

Try it online!

A recursive approach using a local function (given no inputs were allowed).

UnGolfed

()=>{
    return A(1);
    string A(int n) => new string((char)(n+96), n) +
                       (n < 26? "\n" + A(++n) : "");
}

Javascript, 87 bytes, 72 bytes (A lot of thank to @steenbergh)

My first answer too:

for(i=1,j=97;j<123;){console.log(String.fromCharCode(j++).repeat(i++))};

05AB1E, 2 bytes

Aƶ

Try it online!

Note that this outputs as a list of lines, as the OP explicitly allowed. The link uses a version with pretty-print (joined by newlines).

How it works

• A yields the lowercase alphabet.
• ƶ lifts the alphabet (multiplies each element by its index).
• » joins by newlines.

Common Lisp, 65 bytes

(dotimes(a 26)(format t"~v@{~a~:*~}~%"(1+ a)(code-char(+ a 97))))

Try it online!

C (gcc), 68 64 bytes

I know there's another C answer but this is a different approach

n=65;main(i){for(i=n;i-->64;putchar(n));++n>90||main(puts(""));}

Try it online!

JavaScript, 65 bytes

for(x=0;x<26;)console.log(String.fromCharCode(x+97).repeat(++x));

old:

for(x=0;x<26;x++)console.log((function p(a,b){return b==0?a:a+p(a,--b);})(String.fromCharCode(97+x),x));

Octave, 25 24 bytes

['',tril((x=65:90)'+~x)]

Try it online!

Saved one byte thanks to Giuseppe who informed me that OP allows upper case letters.

Explanation:

Create a vector x with the ASCII-values of the upper case alphabet, and transpose it. Add the negated x (thus 26 zeros, in a row vector, in order to create a grid with (the ASCII-values of):

AAAA
BBBB
CCCC

Take the lower triangular matrix and convert to characters by concatenating with the empty string.

Ruby, 32 30 bytes

-2 bytes thanks to @EricDuminil.

27.times{|n|puts (n+96).chr*n}

Try it online!

Wolfram Language (Mathematica), 43 bytes

This submission creates the specified output string exactly - in other words, it's NOT an array of string-enclosed characters.

#~Table~#2<>"\n"&~MapIndexed~Alphabet[]<>""

Try it online!

T-SQL, 68 bytes

Using a variable and loop:

DECLARE @ INT=1;a:PRINT REPLICATE(CHAR(@+96),@)SET @+=1IF @<27GOTO a

Longer (94 bytes), but feels much more SQL-like, using a recursive CTE to generate a number table:

WITH t AS(SELECT 1n UNION ALL SELECT n+1FROM t WHERE n<26)
SELECT REPLICATE(CHAR(n+96),n)FROM t

Befunge-98 (FBBI), 27 bytes

1+:0\::'`j'@+\k:$$>:#,_$a,

where  is a substitution character (ASCII 26)

Try it online!

Uses uppercase letters, and has a trailing newline.

Explanation

The code works by storing a counter (0 initially), and on every loop:

• 1+ - Increments it by 1
• :0\:: - Pushes things so that the stack looks like this: bottom [N, 0, N, N, N] top
• '`j'@ - Checks if the counter is greater than 26
  • j'@ - If it is, we jump over the ' and exit using @
  • j'@ - If it isn't, we execute the ', which pushes the ASCII value of @ to the stack

Now the stack looks like this: bottom [N, 0, N, N, 64] top

• +\ - Adds, then switches the top 2: bottom [N, 0, (N+64), N] top The first time through, this is ASCII 65, or A
• k: - Duplicates the second from the top (N+1) times - now there are (N+2) values of (N+64) on the stack (plus the N and 0 from earlier)
• $$ - Throw away the top 2 values - now there are only N values of (N+64)
• >:#,_ - Prints each top value until it gets to a 0 - this means N copies of (N+64) get printed
• $ - Throws away the 0 - Now the stack is just N
• a, - Prints an enter

And it repeats

I like how I used the @ both for ending the program and for adding to the counter.

Acc!!, 74 bytes

97
Count i while i-27 {
 	Count t while t-i {
 		Write _+i-1
	}
Write 10
}

Try it online!

MATL, 11 bytes

2Y2t!g*!YRc

Try it online!

Uses broadcast multiplication with ones to get a big square 26x26 matrix of the desired letters. Next, the lower triangular part is taken, and implicitly printed.

Also 11 bytes:

2Y2!t~!+YRc  % Using broadcast addition with zeroes
2Y2!l26X"YR  % Using 'repmat'

Perl 6,  24  23 bytes

.say for 'a'..'z'Zx 1..*

Try it

.say for 'a'..*Zx 1..26

Try it

Elixir, 47 bytes

for x<-?a..?z,do: IO.puts List.duplicate x,x-96

Try it

PowerShell, 30 bytes

1..26|%{"$([char]($_+96))"*$_}

Try it online!

Also 30 bytes --

1..26|%{(""+[char]($_+96))*$_}

Try it online!

In either case, we're just looping 26 times, each iteration constructing a string of the appropriate character, then string-multiplying it out to the appropriate length. Ho-hum.

J, 18 17 bytes

a.{~(#"0+&96)i.27

Explanation:

              i.27      - list of integers 0 - 26
     (   +&96)          - adds 96 to the above list (starting offset of 'a')
      #"0               - copies the right argument left argument times  
  {~                    - select items from a list (arguments reversed)
a.                      - the whole alphabet


#"0 +&96 is a hook, which means that at first +96 is applied to the list i.27,
resulting in a list 96, 97, 98... 122, then #"0 is applied to this result. 
So it is evaluated as ((i.27)#"0(96+i.27)){a:

Try it online!

K (oK), 16 bytes

Solution:

`c$t#'96+t:1_!27

Returns a list of lists. TIO prints to stdout:

Try it online!

Explanation:

`c$t#'96+t:1_!27 / the solution
             !27 / til 27, creates range of 0..26
           1_    / drop first element, 1..26 (could have done 1+!26 but 1_!26 is faster ;))
         t:      / store in variable v
      96+        / add 96 to each (97=a)
   t#'           / t take each, 1#97 = 97, 2#98 = 98 98, 3#99 = 99 99 99 etc
`c$              / cast to characters

Brachylog, 7 bytes

Ại₁j₎ẉ⊥

Try it online!

Explanation

Ạ         The alphabet string "abcdefghijklmnopqrstuvwxyz"
 i₁       A couple: [a letter of the alphabet, its index (1-indexed) in it]
   j₎     Juxtapose that letter as many times as its index
     ẉ    Write followed by a linebreak
      ⊥   False: try another couple of [letter, index]

PHP, 47 46 bytes

for($c=a;$i<26;)echo"
",str_pad($c,++$i,$c++);

or

for($c=a;$i<26;)echo str_pad("
",++$i+1,$c++);

Run with -nr or try it online.

JavaScript (ES6), 54 bytes

f=(n=9)=>++n<36?n.toString(36).repeat(n-9)+`
`+f(n):''

O.innerText = f()

<pre id=O></pre>

QBIC, 23 bytes

[26|[a|?chr$(a+96)';`]?

Explanation

[26|   FOR a = 1 TO 26
[a|      FOR b = 1 TO a
?chr$(     PRINT the character
a+96)         a, or b, or c depending on outer loop
';`           and suppress new-lines, tabs etc
]          NEXT, for this character (a, bb, ccc)
?          PRINT a newline between a, bb, ccc....
       NEXT on outer loop added implicitly

Rust, 82 bytes

||for i in 1..27u8{println!("{}",((i+96) as char).to_string().repeat(i as usize))}

I had hoped that it would've been a lot shorter, but explicitly converting/casting between types takes a lot of bytes :(

Try it online!

Retina, 20 bytes

:`
a
{2`
$`
T:`_l`l_

Try it online!

Prints a couple of trailing linefeeds.

Explanation

:`
a

Initialise the string to a and print it.

{2`
$`

The { tells Retina to loop the remainder of the program until it fails to change the string. The stage itself duplicates the first character.

T:`_l`l_

This increments all letters using transliteration and prints the result.

Perl 5, 19 bytes

say$_ x++$"for a..z

Try it online!

Befunge, 37 35 bytes

:"a"+:>,#:\:#->#1_55+,$"`"-:55*`#@_

Try it online!

Explanation

The program starts with an implicit zero on the stack, representing the repeat count (off by 1).

:"a"+                                Duplicate the count and convert it to a character.
     :                               Duplicate the character prior to writing it out.

      >                              Start the output loop.
       ,                             Write the duped character to stdout.
          \                          Swap the count to the top of the stack.
           :  >  _                   Duplicate it and check if zero, returning left if not.
             -  1                    Decrement the count.
          \                          Swap the character back to the top.
         :                           Duplicate it prior to writing it out again.
      >                              Repeat the loop.

                 _                   If the count reached zero, we continue right.
                  55+,               Output a linefeed.
                      $              Drop the zero count.
                       "`"-          Convert the character to a numeric count and increment.
                           :55*`     Check if greater than 25.
                                #@_  If so, then terminate, else wrap back to the start.

Japt, 9 bytes

;C£RiXpYÄ

Try it online!

BASH, 59 54 40 bytes

for l in {a..z};{
a+=a
echo ${a//a/$l}
}

Try it online!

thx. 5 bytes to @Justin Mariner

C (gcc), 53 bytes

i,j;f(){i=i-putchar(j++-i?96+i:(j=!++i)+10)-16&&f();}

Prints a leading newline. Has undefined behaviour, but works with gcc...

Try it online!

C, 54 bytes

j;main(i){for(;i<27;)putchar(j++-i?96+i:(j=!++i)+10);}

Try it online!

C, 54 bytes

i,j;f(){putchar(j++-i?96+i:(j=!++i)+10);(i%=27)&&f();}

Prints a leading newline.

Try it online!

C, 56 bytes

main(i,j){for(;i<27;)for(j=++i;j--;)putchar(j?95+i:10);}

Try it online!

Charcoal, 6 bytes

Ｅβ×ι⊕κ

Try it online! Link is to verbose version of code. Explanation:

     κ  Index
    ⊕   Incremented
   ι    Character
  ×     Repeated
 β      Lowercase letters
Ｅ       Map over each character
        Implicitly print each result on its own line

R, 38 bytes

A relatively uninteresting answer. Iterate for i from 1 to 26, print the ith letter of the alphabet i times (with an implicit line break).

for(i in 1:26)print(rep(letters[i],i))

Try it online!

A more interesting approach might be to use something like the following:

cat(letters[(1:351*2)^.5+.5])

This gives us all the letters in the right amount, but no linebreaks. Perhaps someone smarter than me can figure out a way to use that to make a golfier answer.

Funky, 42 bytes

fori=1i<27i++print("a".char(96+i)::rep(i))

Try it online!

brainfuck, 74 bytes

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

Try it online!

Explanation

++++++++[>+>+++>++++++++++++<<<-]>++>++>+>+
TAPE:
  000
  010   C_NEWLINE
  026   V_ITERCOUNT
  097   V_ALPHA
 >001<  V_PRINTCOUNT
  000   T_PRINTCOUNT

V_ITERCOUNT TIMES:      <<[-   

  V_PRINTCOUNT TIMES:     >>[-
    INC T_PRINTCOUNT        >+
    OUTPUT V_ALPHA          <<.
                          >]

  RESTORE V_PRINTCOUNT    >[-<+>]
  INC V_PRINTCOUNT        <+
  INC V_ALPHA             <+
  OUTPUT C_NEWLINE        <<.
                        >]

Try it online!

Jelly,  5  4 bytes

^{sneaky Python implementation abuse}

-1 byte thanks to Adám (outputting a list of lines has been allowed; as, now, has writing a function rather than a program)

Øa×J

A niladic link that returns a list of strings, the lines
(to print it with the newlines as a full program just add Y back in).

Try it online! (the footer calls the link as a nilad (¢) and gets the Python representation of the result (ŒṘ) for clarity as the default full-program behaviour would smash the result together like abbccc...)

How?

Øa×J - main link: no arguments
Øa   - yield the alphabet = ['a','b','c',...,'z']
   J - range of length    = [1,2,3,...,26]
  ×  - multiplication     = ["a","bb","ccc",...,"zzzzzzzzzzzzzzzzzzzzzzzzzz"]
     - (Python multiplication lengthens chars to strings - not usually a Jelly thing)

JavaScript, 113 bytes

(function(){var i=0,j=0,s;while(++i<=26){s="";j=0;while(++j<=i)s+=String.fromCharCode(96+i);console.log(s);}})();

Stacked, 14 bytes

[26~>:96+chr*]

Try it online!

Pushes a list of lines to the stack.

Explanation

[26~>:96+chr*]
[            ]  anonymous function, takes no arguments
 26~>           range from 1 to 26
     :96+       push range from 97 to 122 (97..122')
         chr    convert each of these to a char ('a'..'z')
            *   repeat each char by the former amount ('a' 'bb' 'ccc' ...)

Mathematica, 33 bytes

Alphabet[][[#]]~Table~#&~Array~26

Try it online!

C# (.NET Core), 78 bytes

n=>{var s="";for(int i=1;i<27;)s+=new string((char)(i+96),i++)+'\n';return s;}

Try it online!

Python 3, 37 bytes

for k in range(27):print(chr(k+96)*k)

Prints a leading newline (which is allowed).

Try it online!

Haskell, 27 bytes

[c<$['a'..c]|c<-['a'..'z']]

Try it online! Returns a list of lines. (Thanks to @totallyhuman for pointing out that this is now allowed)

Explanation:

             c<-['a'..'z']  -- for each character c from 'a' to 'z'
[           |c<-['a'..'z']] -- build the list of
[   ['a'..c]|c<-['a'..'z']] -- the lists from 'a' to c, e.g. "abcd" for c='d'
[c<$['a'..c]|c<-['a'..'z']] -- with each element replaced by c itself, e.g. "dddd"

Haskell, 31 bytes

-12 bytes thanks to nimi.

zipWith replicate[1..26]['a'..]

Try it online!

This is not a snippet, it is a nullary function (one that takes no arguments) that outputs a list of lines which is allowed because of this meta consensus.

Pip, 9 bytes

FczPcX++i

Try it online!

In pseudocode, this is

For-each c in z
    Print (c string-multiply ++i)

where z is preset to the lowercase alphabet and i is preset to 0.

Map-based solutions take one extra byte because they need the -n flag to display on multiple lines:

{aX++i}Mz
B X_+1MEz

VBA, 33 Bytes

Anonymous VBE immediate window function that outputs to the VBE immediate window

For i=1To 26:?String(i,96+i):Next

Pyth, 7 bytes

.e*hkbG

Try it online!

Outputs a list of lines. If that's not allowed, add a j to the start and let me know to add one byte to the count!

.e*hkbG  Full program - outputs to stdout
.e       map over
      G  the alphabet,
  *  b   repeating each letter
   hk    according to its index+1

Pyke, 5 bytes

G Foh*

Try it here!

       - o=0
G      -  alphabet
  F    - for i in ^:
     * -  ^ * v
   oh  -   (o++)+1

V, 9 bytes

¬az\ÓÎÛäl

Try it online!

Hexdump:

00000000: ac61 7a5c d3ce dbe4 6c                   .az\....l

Python 2, 36 bytes

i=1
exec'print chr(i+96)*i;i+=1;'*26

Try it online!