diff --git a/doc/concepts/inheritance b/doc/concepts/inheritance
new file mode 100644
index 0000000..46bf338
--- /dev/null
+++ b/doc/concepts/inheritance
@@ -0,0 +1,177 @@
+CONCEPT
+        Inheritance
+
+DESCRIPTION
+        Have you noticed how many objects in the system have the same
+        functionality in common? Let's look at rooms for instance, they
+        all have the ability to host people and provide commands. It's
+        not that every room is programmed with the same basic functions
+        again and again, rather it will use a model room and then make
+        some special changes to it. That doesn't work by copying the
+        file.. Ouch! Don't replicate code! But by putting a tiny inherit
+        declaration
+        
+                inherit "<model-class>";
+                
+        at the beginning of your new file. This must come before any local
+        ariables or functions. Once inherited your class will behave just
+        like the model class, because all the public methods are available
+        to the outside world. Now it is in your hands to change such an
+        inherited behaviour. You have the following tools to do so:
+
+        * Access to variables
+
+        It is one of the best design decisions in LPC that variables
+        are not accessible from outside, but you can use inherited
+        variables just as if they were your own. Modifiers apply however.
+
+        * Method overloading
+
+                int method_that_also_exists_in_the_model() {
+                        <your new code>
+                }
+
+        You can simply rewrite a method that is also defined in the model
+        class, and thus change how it behaves. Contrary to other languages
+        in LPC method overloading only matches the name of the method, so
+        even by changing the amount and type of parameters you will mask
+        out the original version of the method. You can even apply other
+        modifiers to it as the original.
+
+        * Calling inherited methods
+
+                int method_that_also_exists_in_the_model() {
+                        <your new code>
+                        return ::method_that_also_exists_in_the_model();
+                }
+
+        You can add to the behaviour of a method by redefining it,
+        then calling it from within your new version. You can actually
+        call inherited methods from anywhere in your code. The double
+        colon tells the compiler you are looking for the inherited
+        variant.
+
+EXAMPLE
+
+        Let's imagine very simple food in a file called "/the/food.c":
+
+                // unless "modified" variables are accessible by inheritors
+                int vitamins = 10;
+
+                // please overload this function with your own description
+                public short() { return "something edible"; }
+
+                // let's do some standard action for food
+                public consume() {
+                        this_player() -> nourish(vitamins);
+                        destruct(this_object());
+                }
+
+        And now someone else decides to do some italian cooking in a
+        file called "/the/fusilli.c"
+
+                inherit "/the/food";
+
+                // we have our own variables.
+                int gone_cold = 0;
+
+                // and we simply redefine the short() function to replace it
+                public short() {
+                    // description changes depending on gone_cold
+                    return "a "+( gone_cold ? "stinking" : "steaming" )
+                            +" plate of fusilli";
+                }
+
+                // we have a new function to make food go cold
+                private deteriorate() {
+                    gone_cold = 1;
+                    write("The fusilli have gone cold.\n");
+                }
+
+                // assume this gets called at creation
+                private create() {
+                    // we can access the variable we inherited from food.c
+                    vitamins = 44;           // tomato has plenty of vitamins
+
+                    // go cold in 5 minutes
+                    call_out( #'deteriorate, 5 * 60 );
+                }
+
+                // we can overload the function even with new parameters
+                public consume(how) {
+                    // fetch the name of the person, or use "Someone"
+                    string name = this_player() -> name() || "Someone";
+
+                    if (!gone_cold) {
+                        write("You enjoy a delicious plate of fusilli.\n");
+                        say(name +" guzzles a plate of hot fusilli.\n");
+                    }
+                    else if (how == "quickly") {
+                        write("You eat the fusilli so quickly you "
+                              "hardly notice they have gone cold.\n");
+                        say(name +" wolfs down a plate of cold fusilli.\n");
+                    }
+                    else {
+                        write("You eye the plate and wonder if you "
+                              "really feel like eating cold fusilli.\n");
+                        return; // don't eat
+                    }
+
+                    // and here comes the most important part:
+                    // we execute consume() from food.c, so we
+                    // actually inherit its behaviour.
+                    ::consume();
+                }
+
+ADVANCED USAGE
+
+        * Doing multiple inheritance
+
+        While the Java(TM) language has so-called interfaces as a kludge,
+        LPC doesn't need them as it supports real multiple inheritance.
+        A very powerful feature, it lets you combine the behaviour of
+        several classes into a new one. Simply put several lines of
+        inherit declarations underneath each other. If you have name
+        collisions in the namespace of inherited methods, you will have
+        to address them explicitely with a "the/file"::method(args) syntax.
+
+        * Wildcarded multiple inheritance
+
+        LDMUD 3.2.1@117 introduces an advanced voodoo syntax which allows
+        you to call several methods in model classes at once, but for some
+        technical reasons it cannot pass any arguments. This works by
+        writing a glob type match ('*' and '?' wildcards) into the string
+        in front of the double colon, as in "*"::create(). I wouldn't
+        recommend you to use this, it's better to be clearly conscious of
+        what you inherit and do. But if you're desperate, there you go.
+
+ADVANCED EXAMPLE
+
+          inherit "foo";
+          inherit "bar";
+          inherit "baz";
+          inherit "ball";
+
+          reset() {
+                "ba?"::reset();
+                // calls bar::reset() and baz::reset()
+
+                "ba*"::reset();
+                // calls bar::reset(), baz::reset() and ball::reset()
+
+                "*"::reset();
+                // calls every inherited reset() function.
+
+                "ball"::rejoice("Listen to italectro today!");
+                // only explicit filename of model class allows
+                // passing arguments to the inherited method
+          }
+
+AUTHOR
+        symlynX of PSYC and Nemesis, with a little help from Someone
+
+SEE ALSO
+        functions(LPC), initialisation(LPC), modifiers(LPC), pragma(LPC),
+        overloading(C)
+        function_exists(efun), functionlist(efun), inherit_list(efun),
+        symbol_variable(efun), variable_exists(efun), variable_list(efun).