So I woke up this morning and decided to put the old Hex vs new Hex argument to bed after watching the TreantMonk baseline video the other day.  I figured I could write a mini-program to simulate 10,000 Eldritch Blasts and add the damage values for each version together and OBVIOUSLY old Hex would win by a landslide at all levels.  I mean new Hex caps out at 3d6 of damage, while old hex can do 4d6 per turn once you get four beams to the Eldritch Blast.

I like statistics as much as the next person, but I want to see the REAL DATA where the rubber hits the road to demonstrate that old Hex is better.  Also r/OneDnd is still private, so I decided to post here.

What I found is that up until level 9, it's no contest - old hex rocks.  After level 9 though the higher the number the warlock player needs to roll to hit an enemy, the worse old Hex performs and better new Hex performs.  The lower required dice roll to hit, both perform better but old hex's damage output is higher.

So at higher levels a unequipped finger blasting Warlock would prefer the new Hex, but if you give that Warlock a Rod of the Pact Keeper or a Wand of the Warmage, then they will do more damage with old hex.  

Ultimately I'd prefer that BOTH versions exist in the game and let the player choose which one they want to use in a given situation.  The javascript is below in case anyone else wants to play with the data - I didn't see anyone else post something like this to fiddle with anywhere.  I wrote this assuming the player is casting Hex at the highest level available and is triggering new Hex on the first hit.  You can run it in your browser, just hit the F12 key and paste this into the box on the Console tab then hit Enter.

// Adjust these values
numberOfBlasts = 10000;
warlockLevel = 9;
minimumRollToHit = 12;

// DO NOT adjust anything below this line
const rollsToHit = [];
newHexHitDie = getNewHexHitDie(warlockLevel);
numberOfBeams = getNumberOfBeams(warlockLevel);
totalNewHexDamage = 0;
totalOldHexDamage = 0;
blastsThisTurn = 0;
newHexUsedThisTurn = false;
damageDifference = 0;

for(i = 0; i < numberOfBlasts; i++){
    rollsToHit.push(rollDice(20))
}

console.log(`Roll to hit length is: ${rollsToHit.length}`)
 
rollsToHit.forEach((roll) => {
    blastsThisTurn++;

    if(roll >=  minimumRollToHit){
        totalOldHexDamage += (oldHex(roll));
        if(!(newHexUsedThisTurn)){
            totalNewHexDamage += newHex(roll, newHexHitDie);
            newHexUsedThisTurn = true;
        } 
    }

    if (blastsThisTurn == numberOfBeams) {
        newHexUsedThisTurn = false;
        blastsThisTurn = 0;
    }
});

console.log(`Old Hex did: ${totalOldHexDamage} damage`)
console.log(`New Hex did: ${totalNewHexDamage} damage`)

if(totalOldHexDamage > totalNewHexDamage) {
    damageDifference = (totalOldHexDamage - totalNewHexDamage)
    console.log(`Old Hex did ${damageDifference}  more damage than new Hex`)
} else if(totalNewHexDamage > totalOldHexDamage) {
    damageDifference = (totalNewHexDamage - totalOldHexDamage)
    console.log(`New Hex did ${damageDifference}  more damage than old Hex`)
} else {
    console.log(`Both versions did the same damage and I am a monkey's uncle`)
}

function newHex(diceRoll, numberOfHexDice){
    diceToRoll = numberOfHexDice;
    damage = 0;
    
    if (diceRoll != 20){
        while(diceToRoll > 0){
            damage += rollDice(6);
            diceToRoll -= 1;
        }
    }

    if (diceRoll == 20){
        diceToRoll *= 2
        while(diceToRoll > 0){
            damage += rollDice(6);
            diceToRoll -= 1;
        }
    }
    
    return damage;
}

function getNewHexHitDie(warlockLevel){
    if (warlockLevel < 9) return 1;
    if (warlockLevel < 17) return 2;    
    return 3;
}

function oldHex(diceRoll){
    damage = 0;

    if (diceRoll != 20) damage += rollDice(6);

    if (diceRoll == 20){
        damage += rollDice(6);
        damage += rollDice(6);
    }

    return damage;
}

function getNumberOfBeams(warlockLevel){
    if (warlockLevel < 5) return 1;
    if (warlockLevel < 11) return 2;
    if (warlockLevel < 17) return 3;
    return 4; 
}

function rollDice(diceMax) {
    return (Math.floor(Math.random() * diceMax) + 1);
}

Bladelocks would always choose the new Hex for obvious reasons.

I'd say it highly depends on the context:

If you consider the current 5e warlock with pact magic, the UA Hex is far superior to old Hex.

With the UA warlock, you can't really compare an upcast new Hex to a lvl 1 old Hex. Spending one of your two 3rd level slots at lvl 9 vs one of your four 1st level slots makes it so much more expensive that the slight damage boost is clearly not worth it. But even if you upcast, it is only better for levels 9,10 and 17+. So for the majority of most campaigns, even upcasting doesn't make the new Hex better for the new Warlock

In conclusion: New Hex is better with old Warlock, old Hex is better with new Warlock (except Bladelock).

By the point you hit level 9, you're probably not using hex as much (since there are better more powerful options over hex by that point) which means for most builds, old hex outclasses new hex significantly since the only levels new hex definitely does more damage is as AffenWiesel said, 8, 9 & 17+; meanwhile old hex generally does more damage levels 5-8 & 11-16.

Quote from AffenWiesel >>

I'd say it highly depends on the context:

If you consider the current 5e warlock with pact magic, the UA Hex is far superior to old Hex.

With the UA warlock, you can't really compare an upcast new Hex to a lvl 1 old Hex. Spending one of your two 3rd level slots at lvl 9 vs one of your four 1st level slots makes it so much more expensive that the slight damage boost is clearly not worth it. But even if you upcast, it is only better for levels 9,10 and 17+. So for the majority of most campaigns, even upcasting doesn't make the new Hex better for the new Warlock

In conclusion: New Hex is better with old Warlock, old Hex is better with new Warlock (except Bladelock).

But it doesn't really make sense to compare the old hex with the new warlock vs the new hex with the old warlock. You have to compare it as a whole.

However, the new warlock has better spells to invest his spell slots in than hex. Well, and the old warlock too actually. Except at low levels. But anyway, that's another discussion.

If you compare it as a whole, you don't really compare the variants of the spell. My response was based on the title.

When comparing the full setup, I'd argue that the UA version is better at the low to mid levels. This is based on 

a) the UA warlock only wastes a 1st lvl slot rather than a higher lvl pact slot.

b) the UA warlock has fewer powerfull spells to spend his concentration on. So casting Hex ist still viable (or necessary) on level 5-8.

So, in a way, the fact that the UA warlock is the weaker spellcaster makes Hex (regardless of which version) a more viable option.

To be clear, I'm not posting to discuss a warlock using hex instead of other spells at higher levels.  I'm comparing the damage output of the two versions of hex with 10,000 sample "to hit" rolls against different minimum d20 thresholds to hit a target.  Spell slot cost is being ignored because that cost isn't as easy to quantify programmatically.  Also a 2014 Warlock could multiclass a single level into a Sorcerer and spend a level 1 spell slot to save the Pact magic - again, my bias is FOR the 2014 version of Hex.  The data for the UA Hex shocked me because it was more effective than I gave it credit for.  I had to compare the two side by side over MANY iterations at several different levels to understand that - playtesting a handful of dice rolls didn't illustrate that.

The argument I am making is that after level 9, when multiple Eldritch Blasts are more likely to hit (when the minimumRollToHit is lower) the old Hex is more effective by a small magnitude.  When when multiple Eldritch Blasts are less likely to hit (when the minimumRollToHit is higher) the new Hex is more effective by a large magnitude.  

I am suggesting advocating for BOTH spells to have a place in the Warlock's spell list.  Call one Hex and the other Jinx - different situations favor different versions of the spell, so let the players decide what to use.

Technically, you wouldnt have to run any iterations. You could compute the damage using propability and simply change the default 60% hit chance. But isnt the whole point of bounded accuracy that this shouldn't bei necessary?

Regarding Hex: why have both when the difference in most cases is only marginal, one of them ist more expensive to cast and neither of them ist worth casting in the first place.

EDIT: Python program for calclulating the avg. damage without sampling:

# specify the warlock levels you are interested in
# and an expected enemy AC for each warlock level
warlockLvls =   [   1,  4,  5,  8,  9,  11, 17]
enemyAC =       [  13, 14, 15, 16, 17,  17, 20]

# !!! don't adjust anything below this line !!!

def n_beams(lvl):
    return 1 + (lvl + 1) // 6


def pb(lvl):
    return 2 + (lvl - 1) // 4


def abilityMod(lvl):
    return min(5, 2 + lvl // 4)


def attack(lvl):
    return pb(lvl) + abilityMod(lvl)


def chanceToMiss(at, ac):
    return min(max(ac - at - 1, 1), 19) / 20


def chanceToHit(at, ac):
    return 1 - chanceToMiss(at, ac)


def old_hex(lvl, ac):
    hit = chanceToHit(attack(lvl), ac)
    crit = 1 / 20
    return 3.5 * (hit + crit) * n_beams(lvl)


def new_hex(lvl, ac):
    dmg = 3.5 * (1 + (lvl - 1) // 8)
    n = n_beams(lvl)
    hit = chanceToHit(attack(lvl), ac)
    miss = chanceToMiss(attack(lvl), ac)
    atLeastOneHit = 1 - miss ** n
    # note that the chance to crit is slightly higher than 5%
    crit = 1 / 20 / hit * atLeastOneHit
    return dmg * (atLeastOneHit + crit)


if __name__ == "__main__":
    if len(warlockLvls) != len(enemyAC):
        print("ERROR: There must be an enemy AC specified for each Warlock level")
        exit(1)

    for lvl, ac in zip(warlockLvls, enemyAC):
        print(
            "lvl: %d, enemy AC: %d, chance to hit: %3.0f%%"
            % (lvl, ac, 100 * chanceToHit(attack(lvl), ac))
        )
        print("old hex dmg: %0.2f" % old_hex(lvl, ac))
        print("new hex dmg: %0.2f" % new_hex(lvl, ac))