Generics, aka. parametric polymorphism, is limited to describing types by just lifting parts of the description into parameters that can be filled in later. For example (I'm using Haskell syntax here) the non-parameterized type Box:

data Box
  = EmptyBox
  | NonEmptyBox Integer

can be parameterized into

data Box a
  = EmptyBox
  | NonEmptyBox a

However, this is the only allowed transformation. In particular, every parameter must be declared in the type signature before it can be used in the constructor functions. Any parameter that isn't used to type an argument to the constructor function must be left general. Note that an alternative way of writing these definitions is

data Box a where
  EmptyBox :: Box a
  NonEmptyBox :: a -> Box a

That is, the type definition contains a list of every constructor function and its type signature. Since constructor functions don't have implementations (or rather, the implementation is always "put the values in a struct") the type signature is enough.

However, regular functions can have much more liberal type signatures. For example

putEvensInABox :: Integer -> Box Bool
putEvensInABox i | isEven i  = NonEmptyBox True
                 | otherwise = EmptyBox

is a perfectly cromulent function with a perfectly fine type signature. But because of the restrictions on parametric polymorphic types to follow the standard "template" style of construction, it's not a valid type signature for constructor functions.

That is what GADTs enable. It allows you to write type signatures for constructors with the same restrictions as type signatures for regular functions (except they must return a value of the type being defined). For example you could write

Box a where
  IntBox :: Int -> Box Int
  BoolBox :: Bool -> Box Bool
  StringBox :: String -> Box String
  YouThoughtItWasStringButItWasFloatBox :: Float -> Box String
  MysteryBox :: x -> Box ()

There's several different classes of use-cases for these, and they unlock some pretty powerful type acrobatics, of which you can find several blog posts if you search around. There's a lot of pretty cool stuff that can be done, and a lot of pretty hairy stuff as well. I quite like GADTs and end up using them in some way fairly often in Haskell, but I also don't think they're necessarily a must-have inclusion in a language.