Red, 86 78 bytes

a:""repeat k 26[print take/part append a"ABCDEFGHIJKLMNOPQRSTUVWXYZ"k * 2 - 1]

Try it online!

Setanta, 104 93 bytes

s:="ABCDEFGHIJKLMNOPQRSTUVWXYZ"*26le i idir(0,26){i=2*i+1scriobh(cuid@s(0,i))s=cuid@s(i,999)}

try-setanta.ie link

brainfuck, 242 bytes

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

Try it online!

Ungolfed:

Initial Cell Values:
0  1  2  3  4  5  6  7  8   
0  65 10 26 26 1  0  1  1  

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

Try it online!

Vyxal j, 9 bytes

kA₅ẋ:żd‹ẇ

Try it Online!

How?

kA₅ẋ:żd‹ẇ
kA        # Push the uppercase alphabet
  ₅       # Push the length without popping (26)
   ẋ      # Repeat it that many times
    :ż    # Duplicate and get range [1, length]
      d   # Double each
       ‹  # Decrement each
        ẇ # Split the repeated alphabet into chunks of that sizez

05AB1E, 9 bytes

A26×ā·<£»

Try it online!

Outputs a zillion trailing newlines, but whatever.

Pyramid Scheme, 1492 bytes

    ^         ^
   / \       / \
  /set\     /do \
 ^-----^   ^-----^
/a\   ^-  /!\   /[\
---  ^-  ^---  ^---^
    ^-  /=\   ^-  / \
   ^-  ^---^  -^ /out\
  ^-  ^-  /a\ ^- -----^
 ^-  / \  ---/[\     / \
 -^ /51 \   ^---^   /chr\
 ^- -----  ^-  / \  -----^
 -^       ^-  /do \     / \
 ^-      ^-  ^-----^   /10 \
 -^     /[\  -^   ^-   -----
 ^-    ^---^  -^  -^ 
 -^   / \  -^ /c\ ^-  
 ^-  /set\ /[\--- -^    
^-  ^-----^---^   ^-
-^ /a\   /+\  -^  -^
^- ---  ^---^  -^  -^
-^     /a\ /2\ / \  -^
 -^    --- ---/set\  -^
  -^         ^-----^ ^-
   -^       /c\   /a\-^
    -^      ---   --- -^
     -^               /[\
      -^             ^---^
       -^           ^-   -^
       /]\         / \    -^
      ^---^       /set\    -^ 
     ^-   -^     ^-----^    -^
    / \   ^-    /c\   /-\    -^
   /set\ ^-     ---  ^---^    -^
  ^-----^-          /c\ /1\    -^
 /b\   / \          --- ---    /]\
 ---  / -1\                   ^---^
      -----                  ^-  / \
                            / \ /out\
                           /set\-----^
                          ^-----^    -^
                         /b\   /?\    -^
                         ---  ^---^   / \
                             /!\  -^ /chr\
                            ^---  /+\-----^
                           /=\   ^---^   /+\
                          ^---^ /b\ /1\ ^---^
                         /b\ / \--- ---/ \ /b\
                         ---/25 \     /65 \---
                            -----     -----

Try it online!

Why? Why not?

K4, 25 bytes

Solution:

-1(0,+\1+2*!25)_676#.Q.A;

Example:

q)k)-1(0,+\1+2*!25)_676#.Q.A;
A
BCD
EFGHI
JKLMNOP
QRSTUVWXY
ZABCDEFGHIJ
KLMNOPQRSTUVW
XYZABCDEFGHIJKL
MNOPQRSTUVWXYZABC
DEFGHIJKLMNOPQRSTUV
WXYZABCDEFGHIJKLMNOPQ
RSTUVWXYZABCDEFGHIJKLMN
OPQRSTUVWXYZABCDEFGHIJKLM
NOPQRSTUVWXYZABCDEFGHIJKLMN
OPQRSTUVWXYZABCDEFGHIJKLMNOPQ
RSTUVWXYZABCDEFGHIJKLMNOPQRSTUV
WXYZABCDEFGHIJKLMNOPQRSTUVWXYZABC
DEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKL
MNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVW
XYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJ
KLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXY
ZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOP
QRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHI
JKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCD
EFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZA
BCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ

Explanation:

Slice up a list of the alphabet repeated 26 times...

-1(0,+\1+2*!25)_676#.Q.A; / the solution
-1                      ; / print to STDOUT and swallow return
                    .Q.A  / uppercase alphabet A-Z
                676#      / 676 take from the alphabet
               _          / cut at indexes given by left
  (           )           / do this stuff together
           !25            / range 0..24
         2*               / multiply by 2
       1+                 / add 1
     +\                   / calculate sums of list
   0,                     / prepend 0

MY-BASIC, 72 bytes

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

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

Try it online!

Visual Basic .NET (Mono), 136 bytes

Declared Subroutine that takes no input and outputs to the console.

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

Try it online!

uBASIC, 68 bytes

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

That pesky Chr$(...) function is forcing me to use Left$(...,1) again.

0ForI=1To51:ForJ=1ToI:K=KMod26+1:?Left$(Chr$(64+K),1);:NextJ:?:NextI

Try it online!

Yabasic, 63 bytes

Long live BASIC.

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

Try it online!

VBA Excel (80 bytes, 1742 bytes)

Excel, 1742 bytes

Inspired by the ugoren's creative answer, I managed to find an Excel formula to create the pattern as shown in the OP.

=MID(REPT("ABCDEFGHIJKLMNOPQRSTUVWXYZ",26),(ROW()-1)^2+1,2*ROW()-1)

Paste this formula in cell A1, then drag all over range A1:A26.

The length of the formula is 67 bytes but you have to replicate it 26 times, so it's equal to 67*26=1742 bytes. Here is the output:

Excel VBA, 80 bytes

Now it's possible we integrate Excel with VBA to automate the process and to save many bytes since VBA is built into most Microsoft Office applications, including Excel. Write and run the following code in the Immediate Window (use combination keys CTRL+G to display it in Visual Basic Editor):

[A1:A26]="=MID(REPT(""ABCDEFGHIJKLMNOPQRSTUVWXYZ"",26),(ROW()-1)^2+1,2*ROW()-1)"

The program works by printing the Excel formula above to the range A1:A26. Unfortunately, both Excel and VBA have no built-in alphabet.

Husk, 10 bytes

Cİ1ṠṁK…"AZ

Try it online!

Explanation

Cİ1ṠṁK…"AZ
      …"AZ    Get the alphabet
   ṠṁK        Replace each letter with the whole alphabet
C             Cut the resulting string into lines with lengths
 İ1            equal to the list of odd numbers

Common Lisp, 139 bytes

(let((a"abcdefghijklmnopqrstuvwxyz"))(do((n 3(+ n 2))(i 0 j)(j 1(+ j n))(b a(format()"~a~a"b a)))((= n 55))(format t"~a~%"(subseq b i j))))

Try it online!

JavaScript (Using external library - Enumerable) (90 88 86 80 bytes)

Link to lib: https://github.com/mvegh1/Enumerable

(z=_.Range)(0,26).WriteLine(x=>z(x*x,2*x+1).Write("",y=>(y%26+10).toString(36)))

Code explanation: Create range of ints 0 to 25, and for each write a new line according to the predicate. For each line, create a range of ints starting at the square of the current int, for a count of 2x+1. Then take that range, and join it into a string delimited by nothing where each int is casted to the String represented by the int ascii code

R, 81 73 65 63 bytes

A simple for loop approach. Repeat the alphabet 26 times and loop through a sliding index range that is calculated using (i^2-2*i+2):i^2.

for(i in 1:26)cat(rep(LETTERS,26)[(i^2-2*i+2):i^2],"\n",sep="")

Pip, 17 16 bytes

15 bytes of code, +1 for -n flag.

zX26^@(1,27)**2

Try it online!

Explanation:

zX26             Lowercase alphabet, repeated 26 times
    ^@           Split at these indices:
       1,27        Range(1,27), i.e. numbers 1 through 26
      (    )**2    Square each number
                 Autoprint the resulting list, joined on newlines due to -n

My first solution is longer, but I think it's pretty cute:

L26P(zy,Y++++v+y)

Explanation:

L26               Loop 26 times:
      y             y is initially "", which is 0 in numeric context
       ,            Range from y to the following value:
         ++++v        v is initially -1; increment it twice (so it goes 1, 3, 5, ...)
        Y     +y      Add previous y to new v and yank result into y for next iteration
    (z          )   Use that range to get a slice from the lowercase alphabet (with
                    cyclical indexing)
   P                Print the slice (with trailing newline)

05AB1E, 14 13 11 bytes

A27×26L·<£»

Try it online!

Explanation:

A27×         # Push the alphabet repeated 27 times
    26L      # Push [1, 2, ..., 26]
       ·     # Multiply by 2 [2, 4, ..., 52]
        <    # Subtract 1 [1, 3, ..., 51]
         £   # Repeated slice
          »  # Join by newlines
             # Implicit print

Racket 160 bytes

(let p((n 65)(t 0)(x 0))(when(> n 90)(set! n 65))(when(> x t)(set! t(+ 2 t))
(set! x 0)(displayln""))(when(< t 51)(display(integer->char n))(p(+ 1 n)t(+ 1 x))))

Ungolfed:

(define (f)
  (let loop ((n 65)
             (t 0)
             (x 0))
    (when (> n 90)
      (set! n 65))
    (when (> x t)
      (set! t (+ 2 t))
      (set! x 0)
      (displayln ""))
    (when (< t 51)
        (display (integer->char n))
        (loop (add1 n) 
              t 
              (add1 x)))))

Testing:

(f)

Output:

A
BCD
EFGHI
JKLMNOP
QRSTUVWXY
ZABCDEFGHIJ
KLMNOPQRSTUVW
XYZABCDEFGHIJKL
MNOPQRSTUVWXYZABC
DEFGHIJKLMNOPQRSTUV
WXYZABCDEFGHIJKLMNOPQ
RSTUVWXYZABCDEFGHIJKLMN
OPQRSTUVWXYZABCDEFGHIJKLM
NOPQRSTUVWXYZABCDEFGHIJKLMN
OPQRSTUVWXYZABCDEFGHIJKLMNOPQ
RSTUVWXYZABCDEFGHIJKLMNOPQRSTUV
WXYZABCDEFGHIJKLMNOPQRSTUVWXYZABC
DEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKL
MNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVW
XYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJ
KLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXY
ZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOP
QRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHI
JKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCD
EFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZA
BCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ

Actually, 27 26 22 20 17 bytes

Takes the lowercase alphabet 26 times, prints 1,3,5,...,(2*n+1) at a time. Golfing suggestions welcome. Try it online!

Edit: Many thanks and -4 bytes to Leaky Nun and his suggestions.

úlú*iúl`╜u╟Σ)2╖`n

Ungolfing:

úl    Pushes 26 (the length of the lowercase alphabet).
ú*    26 * the lowercase alphabet.
i     Flatten the string.
úl    Pushes 26.
  `     Start function.
  ╜u    Push register 0 (default: 0) and increment (call it len, from now on)
  ╟     Take len elements from the stack
  Σ     sum() into a string.
  )     Rotate the string to the bottom of the stack.
  2╖    Add 2 to register 0.
  `     End function.
n     Run the above function (26) times.

Dyalog APL, 31 25 23 bytes

Requires ⎕IO←0, which is default on many systems.

↑(∊1,¨0⍴¨⍨2×⍳26)⊂676⍴⎕A

676⍴⎕A cycle the letters to get 676 of them

(...)⊂ split on ones in

 ⍳26 zero through 25; {0, 1, 2, 3, ..., 25}

 2× multiply them by 2, {0, 2, 4, 6, ..., 50}

 0⍴¨⍨ generate zero-sequences of such lengths; {}, {0}, {0, 0}, etc.

 1,¨ prepend one to each sequence; {1}, {1, 0}, {1, 0, 0}, etc.

 ∊ flatten; {1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, ..., 0}

↑ stack the strings

TryAPL online!

-6 thanks to @jimmy23013

Matlab, 81 bytes

b=char('A'+(1:26)-1)';b=repmat(b,1,26);
for j=1:26
disp(b((j-1)*(j-1)+1:j*j))
end

Python 3, 83 bytes

[print("".join([chr((i%26)+97)for i in range(j*j,(j+1)*(j+1))]))for j in range(26)]

My first golfing experience.

C#, 153 Bytes

using b=System.Console;class a{static void Main(){int i=0,j=0,k=0;while(i<26){b.Write((char)(65+j));j++;j%=26;k++;if(2*i+1==k){b.WriteLine();i++;k=0;}}}}

Compile using Microsoft .NET Framework 2.0 or later. (Written using Visual Studio 2015 Update 3.)

Perl 6: 50 bytes

Regex based solution:

.put for (("A".."Z").join x 26)~~m:g/.**{1+2*$++}/

Perl 6: 51 bytes

say .join for (|("A".."Z")xx*).rotor(1,3...51)[^26]

R, 120 115 111 bytes

v=c();for(i in 1:26){v=c(v,c(rep(LETTERS,26)[(sum((b=seq(1,51,2))[1:i-1])+1):sum(b[1:i])],"\n"))};cat(v,sep="")

Ungolfed :

a=rep(LETTERS,26)
b=seq(1,51,2)
v=vector()

for(i in 1:26)
    {
    v=c(v,c(a[(sum(b[1:i-1])+1):sum(b[1:i])],"\n"))
    }

cat(v,sep="")

Basically, b is the vector of the odd numbers between 1 and 51, thus giving the length of each line. Obviously, the sum function sums the numbers of this vector, and gives the starting and ending indexes.

-5 bytes thanks to @plannapus !
-4 bytes thanks to @plannapus !

Perl, 42 41 39 bytes

perl -E '@b=(A..Z)x26;say splice@b,0,$#a+=2for@b'

Just the code:

@b=(A..Z)x26;say splice@b,0,$#a+=2for@b

An obvious shorter version unfortunately triggers an internal perl problem (Use of freed value in iteration):

say splice@b,0,$#a+=2for@b=(A..Z)x26

C++, 122 108 bytes

void a(){int a=65,l,i;for(l=1;l<53;l+=2){for(i=0;i<l;i++){std::putchar(a);a>90?a=65:a++;}std::cout<<'\n';}}

First time trying my hand at one of these, so it'll probably be super inefficient.

It creates an integer a, then enters a for loop with l representing the number of characters in a line (stopping when reaching the maximum amount, 53) Inside the loop, it enters another loop based on the value of l, which prints a to the console, then either increments it or sets it back to A. After completing that loop, it prints a newline to extend the pyramid.

EDIT: Improved by changing a from a char to an int, which eliminates the need for (int)a++ among other things and saves precious bytes. Also replaced the while statement with an equivalent for.

PHP, 76 69 bytes

for(;$i<26&&$a.=join(range(A,Z));)echo substr($a,$i**2,1+2*$i++)."
";

• Create 26 alphabet (more than enough) and contactenate them in $a
• loop for i < 26
• display $a substring start i^2, end 2*i+1

C++, 111 bytes

void a(){int c=65,i,j;for(i=0;i<26;i++){for(j=0;j<=2*i;j++){std::cout<<(char)c;c++;if(c==91)c=65;}std::cout<<'\n';}}

First try at one of these. Uses an int "c" to record which letter it needs to print at any given time. Once "c" passes 90 ('Z') it gets reset to 65 ('A'). Prints the pyramid using for loops.

><>, 59 bytes

<v01'5'&0
+>    :@@:@$-?!v$&:d2*%'A'+o1+&1
 ^0;?=}:{:+2oa~<

This increments one item for each letter, another for how many letters in the current row, and checks that one to a constant to halt the program after the last line of 53 characters

Try it online

C, 60 bytes

i;main(j){for(;j<27;j*j^++i||puts("",j++))putchar(i%26+65);}

Dyalog APL, 18 bytes

↑2{⍺↓⍵⍴⎕a}/×⍨0,⍳26

PowerShell, 68 bytes

$a=-join(65..90|%{[char]$_})*26;26..1|%{$a=$a.Insert($_*$_,"`n")};$a

The section before the first semicolon produces a string containing 26 copies of the uppercase alphabet. The next section injects linebreaks at the index of each square number (working backward so I don't have to account for the shifting). Finally, the $a at the end just shoves that string variable onto PowerShell's equivalent of STDOUT.

TSQL, 129 bytes

USE MASTER in the beginning of the script is to ensure that the query is run in the master database which is default for many users(not counting bytes for that).

Golfed:

USE MASTER

SELECT SUBSTRING(REPLICATE('ABCDEFGHIJKLMNOPQRSTUVWXYZ',26),number*number+1,number*2+1)FROM spt_values WHERE number<26and'P'=type

Ungolfed:

USE MASTER

SELECT SUBSTRING(REPLICATE('ABCDEFGHIJKLMNOPQRSTUVWXYZ',26),number*number+1,number*2+1)
FROM spt_values
WHERE number<26and'P'=type

Fiddle

Fiddle for older version using xml path

JavaScript (ES6), 77 82 88

EcmaScript 6 required just to save 1 byte using a template string literal for newline.

for(i=r=l=o='';l+52;r++||(r=l-=2,o+=`
`))o+=(i++%26+10).toString(36);alert(o)

Less golfed

for(i = r = l = o = '';
    l + 52;
    r++ || (r = l -= 2, o += `\n`))
  o += (i++ % 26 + 10).toString(36);
alert(o);

Test

for(i=r=l=o='';l+52;r++||(r=l-=2,o+=`
`))o+=(i++%26+10).toString(36);alert(o)

Rexx, 74 72 bytes

i=1;m=1;do 26;say substr(copies(xrange('A','Z'),26),i,m);i=i+m;m=m+2;end

Ungolfed:

i=1
m=1
do 26
  say substr(copies(xrange('A','Z'),26),i,m)
  i=i+m
  m=m+2
end

05AB1E (alternate) 15 bytes

A2×52µ¼D¾£,¾¼FÀ

Try it online!

Explanation:

A2×              # push a string containing a-za-z
   52µ           # Loop the rest of the program until counter = 52
      ¼          # increment counter (it's 0 initially)
       D         # Duplicate the alpha string on the stack
        ¾£       # Replace alpha with alpha[0..counter]
          ,      # Pop the substring and print it
           ¾¼FÀ  # rotate the alpha string left counter++ times.

Ruby, 46 bytes

26.times{|i|puts ([*?A..?Z]*26)[i*i,i*2+1]*""}

See it on ideone: http://ideone.com/3hGLB0

XPath 3.0 (and XQuery 3.0), 84 bytes

codepoints-to-string((0 to 25)!(subsequence(((1 to 26)!(65 to 90)),.*.+1,2*.+1),10))

Explanation:

(1 to 26)!(65 to 90) is the alphabet 26 times

(0 to 25)!(subsequence(XX, start, len),10) takes 26 subsequences of this, each followed by newline

subsequence(X, .*.+1, 2*.+1) takes successive subsequences with start position and length: (1, 1), (2, 3), (5, 5), (10, 9) etc.

codepoints-to-string() turns Unicode codepoints into characters

Haskell, 67 bytes

_#53=[]
s#i=take i s:drop i s#(i+2)
mapM putStrLn$cycle['A'..'Z']#1

A simple recursion over the length i of the line. In each step the next i chars are taken from an infinite repetition of the alphabet.

Actually, 18 17 bytes

úl`╜²1╖╜²;ú*Ht`na

Ungolfing:

úl    Pushes 26 (the length of the lowercase alphabet).
  `     Start function
  ╜²    Push register 0 (default: 0) and square. Call this a.
  1╖    Increment register 0.
  ╜²;   Push register 0, square and duplicate. Call this b.
  ú*    b times the lowercase alphabet. Call this repeated_alphabet.
  Ht    Get repeated_alphabet[:b][a:]
  `     End function.
n     Run the above function (26) times.
a     Invert the stack.
      Print the stack implicitly with newlines.

Try it online!

05AB1E, 18 17 bytes

26FA26×N>n£NnF¦},

Explanation

26F                 # for N in range(0, 26) do
   A26×             # the alphabet repeated 26 times
       N>n£         # take (N+1)^2 letters
           NnF¦}    # throw away the first N^2 letters
                ,   # print with newline

Try it online!

Java, 109 bytes

for(int i=0,c=-1,j;i<26;i++,System.out.println())for(j=0;j<1+2*i;j++)System.out.print((char)(65+(c=++c%26)));

Slightly ungolfed:

for (int i = 0, c = -1, j; i < 26; i++, System.out.println())
    for (j = 0; j < 1 + 2 * i; j++) System.out.print((char) (65 + (c = ++c % 26)));

Jelly, 10 bytes

26RḤ’RØAṁY

Try it online!

How it works

26RḤ’RØAṁY  Main link. No Arguments.

26          Set the return value to 26.
  R         Range; yield [1, 2, ..., 25, 26].
   Ḥ        Unhalve; yield [2, 4, ..., 50, 52].
    ’       Decrement; yield [1, 3, ..., 49, 51].
     R      Range; yield [[1], [1, 2, 3], ..., [1, ..., 49], [1, ..., 51]].
      ØA    Yield the uppercase alphabet.
        ṁ   Mold the alphabet as the array of ranges. This repeats the uppercase
            letters over an over again, until all integers in the range arrays
            have been replaced with letters.
         Y  Join, separating by linefeeds.

MATLAB, 112 109 95 79 77 bytes

This will also work with Octave, you can try online here.

a=['' 65:90 65:90]';j=0;for i=1:2:52;b=circshift(a,j);j=j-i;disp(b(1:i)');end

So after some major changes, I've saved a further 14 32 bytes. This one is getting to be much more like the length I would have expected from MATLAB. I've left the old version below as it is substantially different.

a=['' 65:90 65:90]';        %Create 2 copies of the upper case alphabet
j=0;                        %Initialise cumulative sum
for i=1:2:52;               %For each line length
    b=circshift(a,j);       %Rotate the alphabet string by the cumulative offset
    j=j-i;                  %Update cumulative negative sum of offsets.
    disp(
         b(1:i)'            %Extract first 'line length' characters from rotated alphabet.
               );           %Display next line (disp adds newline automatically)
end

Original version:

a=['' repmat(65:90,1,26)];c=cumsum(1:2:51);disp(cell2mat(arrayfun(@(s,f)[a(s:f) 10],[1,c(1:25)+1],c,'Un',0)))

Wow that one ended up being longer than I thought it would. I'll see if I can't knock a few bytes off it.

An ungolfed version to explain:

a=['' repmat(65:90,1,26)]; %Create 26 copies of the upper case alphabet
c=cumsum(1:2:51);          %Calculate the end index of each row in the above array, by cumulatively summing the length of each line
disp(
     cell2mat(
              arrayfun(@(s,f)
                             [a(s:f) 10], %Extract the part of the alphabet and insert a new line.
                                         [1,c(1:25)+1],c, %start index is the previous end of line plus 1. End index is as calculated by cumsum.
                       'Un',0 %The returned values are not all the same length
                       )   %Do this for each line
              )            %Convert back to a matrix now new lines inserted
     )                     %And display it

Acknowledgements

• 3 bytes saved - thanks @LuisMendo

Batch, 123 bytes

@set s=
@for /l %%i in (1,2,51)do @call set s=%%s%%ABCDEFGHIJKLMNOPQRSTUVWXYZ&call echo %%s:~0,%%i%%&call set s=%%s:~%%i%%

Brachylog, 37 bytes

26~l<:1aLc~j[@A:I],L~@nw
=:2%1,.#@l?,

Try it online!

Explanation

• Main predicate:

  26~l         Let there be a list of 26 elements
  <            This list is an ascending list of integers
  :1aL         Apply predicate 1 to that list ; the resulting list of strings is L
  c            Concatenate the list of strings into one big string
  ~j[@A:I],    That big string is the result of juxataposing the alphabet I times to itself
  L~@n         Create a string which when splitted on line breaks results in L
  w            Write that string to STDOUT
  

• Predicate 1: used to generate variable strings of odd lengths.

  =            Assign a value to the Input
  :2%1,        That value must be odd
  .#@l?,       Output is a string of length Input
  

C#, 164 bytes

void a(){int i=0;Console.Write(String.Join("\n",Enumerable.Range(0,26).Select(n=>new string(Enumerable.Range(0,n*2+1).Select(m=>(char)(97+(i++)%26)).ToArray()))));}

Vim, 29 bytes

:h<_↵↵↵y$ZZ26P0qqa↵♥βjllq25@q

Where ↵ represents the Return key, ♥ the Escape key, and β the Backspace key.

Pyth, 14 bytes

V26:*26G^N2^hN2

Try it here!

V26             - for N in range(26):
        ^N2     -   N**2
   :*26G        -  (alphabet*26)[^:V]
           ^hN2 -   (N+1)**2

Pyth, 12 bytes

jtc*G26*Rd26

Try it online!

C, 79 bytes

main(i,j){for(i=0,j=1;i<676;i++){putchar(i%26+65);if(j*j==i+1){puts("");j++;}}}

My first answer in C \o/

Golfing suggestions are more than welcome.

Go, 133 bytes

package main
import S "strings"
func main(){s:=S.Repeat("ABCDEFGHIJKLMNOPQRSTUVXXYZ",26)
for i:=1;s!="";i+=2{println(s[:i]);s=s[i:]}}

Python 2, 65 bytes

i=1
a=bytearray(range(65,91))*26
while a:print a[:i];a=a[i:];i+=2

Pyke, 14 bytes

G26*WDoh<
Ko>D

Try it here!

JavaScript, 129 bytes

z=1,i=0,g=a=>{b=0,c="";while(a+a-1>b){c+='ABCDEFGHIJKLMNOPQRSTUVWXYZ'.split``[i>26?i=0:i++];b++}console.log(c)};while(z<26)g(z++)

Mathematica, 90 bytes

StringRiffle[Flatten[Alphabet[]&~Array~26]~Internal`PartitionRagged~Range[1,51,2],"
",""]&

Anonymous function. Takes no input and returns a string as output. Golfing suggestions welcome. An example of what Internal`PartitionRagged does:

In[1]:= Internal`PartitionRagged[{2, 3, 5, 7, 11, 13}, {2, 3, 1}]               

Out[1]= {{2, 3}, {5, 7, 11}, {13}}