+Magic is Perl's way of enhancing variables.
+This mechanism lets the user add extra data to any variable and hook syntactical operations (such as access, assignment or destruction) that can be applied to it.
+With this module, you can add your own magic to any variable without having to write a single line of XS.
+
+You'll realize that these magic variables look a lot like tied variables.
+It is not surprising, as tied variables are implemented as a special kind of magic, just like any 'irregular' Perl variable : scalars like C<$!>, C<$(> or C<$^W>, the C<%ENV> and C<%SIG> hashes, the C<@ISA> array, C<vec()> and C<substr()> lvalues, L<threads::shared> variables...
+They all share the same underlying C API, and this module gives you direct access to it.
+
+Still, the magic made available by this module differs from tieing and overloading in several ways :
+
+=over 4
+
+=item *
+
+Magic is not copied on assignment.
+
+You attach it to variables, not values (as for blessed references).
+
+=item *
+
+Magic does not replace the original semantics.
+
+Magic callbacks usually get triggered before the original action takes place, and cannot prevent it from happening.
+This also makes catching individual events easier than with C<tie>, where you have to provide fallbacks methods for all actions by usually inheriting from the correct C<Tie::Std*> class and overriding individual methods in your own class.
+
+=item *
+
+Magic is multivalued.
+
+You can safely apply different kinds of magics to the same variable, and each of them will be invoked successively.
+
+=item *
+
+Magic is type-agnostic.
+
+The same magic can be applied on scalars, arrays, hashes, subs or globs.
+But the same hook (see below for a list) may trigger differently depending on the type of the variable.
+
+=item *
+
+Magic is invisible at Perl level.
+
+Magical and non-magical variables cannot be distinguished with C<ref>, C<tied> or another trick.
+
+=item *
+
+Magic is notably faster.
+
+Mainly because perl's way of handling magic is lighter by nature, and because there is no need for any method resolution.
+Also, since you don't have to reimplement all the variable semantics, you only pay for what you actually use.
+
+=back