diff --git a/ext/dl/dl.c b/ext/dl/dl.c
index cd4e0c1..7beae9a 100644
--- a/ext/dl/dl.c
+++ b/ext/dl/dl.c
@@ -49,6 +49,20 @@ ID rbdl_id_stdcall;
 #endif
 #define DLTYPE_UINTPTR_T (-DLTYPE_INTPTR_T)
 
+/*
+ * call-seq: DL.dlopen(so_lib)
+ *
+ * == Description
+ * An interface to the dynamic linking loader
+ *
+ * This is a shortcut to DL::Handle.new and takes the same arguments.
+ *
+ * == Example
+ *   libc_so = "/lib64/libc.so.6"
+ *   => "/lib64/libc.so.6"
+ *   libc = DL.dlopen(libc_so)
+ *   => #<DL::Handle:0x00000000e05b00>
+ */
 VALUE
 rb_dl_dlopen(int argc, VALUE argv[], VALUE self)
 {
@@ -56,7 +70,7 @@ rb_dl_dlopen(int argc, VALUE argv[], VALUE self)
 }
 
 /*
- * call-seq: DL.malloc
+ * call-seq: DL.malloc(size)
  *
  * Allocate +size+ bytes of memory and return the integer memory address
  * for the allocated memory.
@@ -103,6 +117,19 @@ rb_dl_free(VALUE self, VALUE addr)
     return Qnil;
 }
 
+/*
+ * call-seq: DL.dlunwrap(addr)
+ *
+ * returns the hexdecimal representation of a memory pointer address +addr+
+ *
+ * == Example
+ *   lib = DL.dlopen('/lib64/libc-2.15.so')
+ *   => #<DL::Handle:0x00000001342460>
+ *   lib['strcpy'].to_s(16)  
+ *   => "7f59de6dd240"
+ *   DL.dlunwrap(DL.dlwrap(lib['strcpy'].to_s(16)))
+ *   => "7f59de6dd240"
+ */
 VALUE
 rb_dl_ptr2value(VALUE self, VALUE addr)
 {
@@ -110,6 +137,17 @@ rb_dl_ptr2value(VALUE self, VALUE addr)
     return (VALUE)NUM2PTR(addr);
 }
 
+/*
+ * call-seq: DL.dlwrap(val)
+ *
+ * returns a memory pointer of a function's hexdecimal address location +val+
+ *
+ * == Example
+ *   lib = DL.dlopen('/lib64/libc-2.15.so')
+ *   => #<DL::Handle:0x00000001342460>
+ *   DL.dlwrap(lib['strcpy'].to_s(16))
+ *   => 25522520
+ */
 VALUE
 rb_dl_value2ptr(VALUE self, VALUE val)
 {
@@ -489,7 +527,7 @@ Init_dl(void)
 
     /* Document-const: SIZEOF_UINTPTR_T
      *
-     * size of a intptr_t
+     * size of a uintptr_t
      */
     rb_define_const(rb_mDL, "SIZEOF_UINTPTR_T",  INT2NUM(sizeof(uintptr_t)));
 
diff --git a/ext/dl/lib/dl.rb b/ext/dl/lib/dl.rb
index 80d46b6..6e74e72 100644
--- a/ext/dl/lib/dl.rb
+++ b/ext/dl/lib/dl.rb
@@ -6,6 +6,7 @@ rescue LoadError
 end
 
 module DL
+  # returns a boolean, of whether Fiddle is defined
   def self.fiddle?
     Object.const_defined?(:Fiddle)
   end
diff --git a/ext/dl/lib/dl/cparser.rb b/ext/dl/lib/dl/cparser.rb
index 7aae9ea..705c545 100644
--- a/ext/dl/lib/dl/cparser.rb
+++ b/ext/dl/lib/dl/cparser.rb
@@ -1,5 +1,12 @@
 module DL
+  # To be used as a mixin.
   module CParser
+    # parses a C struct's members
+    # 
+    # == Example
+    #   parse_struct_signature(['int i', 'char c'])
+    #   => [[4, 2], ["i", "c"]]
+    #
     def parse_struct_signature(signature, tymap=nil)
       if( signature.is_a?(String) )
         signature = signature.split(/\s*,\s*/)
@@ -35,6 +42,14 @@ module DL
       return tys, mems
     end
 
+    # parses a C prototype signature
+    #
+    # == Example
+    #   include DL::CParser
+    #   => Object
+    #   parse_signature('double sum(double, double)')
+    #   => ["sum", 8, [8, 8]]
+    #
     def parse_signature(signature, tymap=nil)
       tymap ||= {}
       signature = signature.gsub(/\s+/, " ").strip
@@ -56,6 +71,21 @@ module DL
       end
     end
 
+    # Given a String of C type +ty+, return the corresponding DL constant.
+    #
+    # +ty+ can also accept an Array of C type Strings, and will returned in a corresponding Array.
+    #
+    # If Hash +tymap+ is provided, +ty+ is expected to be the key,
+    # and the value will be the C type to be looked up.
+    #
+    # == Example
+    #   parse_ctype('int')
+    #   => 4
+    #   parse_ctype('double')
+    #   => 8
+    #   parse_ctype('unsigned char')
+    #   => -2
+    #
     def parse_ctype(ty, tymap=nil)
       tymap ||= {}
       case ty
diff --git a/ext/dl/lib/dl/import.rb b/ext/dl/lib/dl/import.rb
index eec65cd..443ab1f 100644
--- a/ext/dl/lib/dl/import.rb
+++ b/ext/dl/lib/dl/import.rb
@@ -179,11 +179,13 @@ module DL
       f
     end
 
+    # Given a C struct prototype +signature+, construct a DL::CStruct
     def struct(signature)
       tys, mems = parse_struct_signature(signature, @type_alias)
       DL::CStructBuilder.create(CStruct, tys, mems)
     end
 
+    # Given a C union prototype +signature+, construct a DL::CUnion
     def union(signature)
       tys, mems = parse_struct_signature(signature, @type_alias)
       DL::CStructBuilder.create(CUnion, tys, mems)
diff --git a/ext/dl/lib/dl/struct.rb b/ext/dl/lib/dl/struct.rb
index b8becca..cf6e362 100644
--- a/ext/dl/lib/dl/struct.rb
+++ b/ext/dl/lib/dl/struct.rb
@@ -2,19 +2,42 @@ require 'dl'
 require 'dl/pack.rb'
 
 module DL
+  # C struct shell
   class CStruct
+    # accesor to DL::CStructEntity
     def CStruct.entity_class()
       CStructEntity
     end
   end
 
+  # C union shell
   class CUnion
+    # accesor to DL::CUnionEntity
     def CUnion.entity_class()
       CUnionEntity
     end
   end
 
+  # Used to construct C classes (CUnion, CStruct, etc)
   module CStructBuilder
+    # Given a C:
+    # * class +klass+ (CUnion, CStruct, or other that provide an #entity_class), 
+    # * +types+ (DL:TYPE_INT, DL::TYPE_SIZE_T, etc., see the C types constants)
+    # * corresponding +members+
+    # Construct a new class
+    #
+    # == Example
+    #   require 'dl/struct'
+    #   => true
+    #   require 'dl/cparser'
+    #   => true
+    #   include DL::CParser
+    #   => Object
+    #   types, members = parse_struct_signature(['int i','char c'])
+    #   => [[4, 2], ["i", "c"]]
+    #   mystruct = DL::CStructBuilder.create(CUnion, types, members)
+    #   => #<Class:0x00000001413ab0>
+    #
     def create(klass, types, members)
       new_class = Class.new(klass){
         define_method(:initialize){|addr|
@@ -43,15 +66,22 @@ module DL
     module_function :create
   end
 
+  # Subclasses DL::CPtr
   class CStructEntity < CPtr
     include PackInfo
     include ValueUtil
 
+    # Uses DL.malloc, to memory allocate for all +types+ provided
     def CStructEntity.malloc(types, func = nil)
       addr = DL.malloc(CStructEntity.size(types))
       CStructEntity.new(addr, types, func)
     end
 
+    # given +types+, returns the offset for the packed sizes of those types
+    #
+    #   DL::CStructEntity.size([DL::TYPE_DOUBLE, DL::TYPE_INT, DL::TYPE_CHAR, DL::TYPE_VOIDP])
+    #   => 24
+    #
     def CStructEntity.size(types)
       offset = 0
       max_align = 0
@@ -76,15 +106,23 @@ module DL
       offset
     end
 
+    # Creates a new pointer to address +addr+ 
+    # with C +types
+    #
+    # Option function +func+ is called when the instance is garbage collected.
+    # 
+    # See also DL::CPtr.new
     def initialize(addr, types, func = nil)
       set_ctypes(types)
       super(addr, @size, func)
     end
 
+    # set the names of the +members+ in this C struct
     def assign_names(members)
       @members = members
     end
 
+    # given +types+, calculate the necessary offset and size
     def set_ctypes(types)
       @ctypes = types
       @offset = []
@@ -112,6 +150,7 @@ module DL
       @size = offset
     end
 
+    # fetch member +name+
     def [](name)
       idx = @members.index(name)
       if( idx.nil? )
@@ -145,6 +184,7 @@ module DL
       end
     end
 
+    # set member +name+, to value +val
     def []=(name, val)
       idx = @members.index(name)
       if( idx.nil? )
@@ -164,19 +204,27 @@ module DL
       end
     end
 
+    # display as string
     def to_s()
       super(@size)
     end
   end
 
+  # Subclasses DL::CStructEntity
   class CUnionEntity < CStructEntity
     include PackInfo
 
+    # Uses DL.malloc, to memory allocate for all +types+ provided
     def CUnionEntity.malloc(types, func=nil)
       addr = DL.malloc(CUnionEntity.size(types))
       CUnionEntity.new(addr, types, func)
     end
 
+    # given +types+, return the packed size information for those types
+    #
+    #   DL::CUnionEntity.size([DL::TYPE_DOUBLE, DL::TYPE_INT, DL::TYPE_CHAR, DL::TYPE_VOIDP])
+    #   => [8, 4, 2, 1]
+    #
     def CUnionEntity.size(types)
       size   = 0
       types.each_with_index{|t,i|
@@ -191,6 +239,7 @@ module DL
       }
     end
 
+    # given +types+, calculate the necessary offset and size
     def set_ctypes(types)
       @ctypes = types
       @offset = []
