 
         # returns the prefix of a css style in "javascript" style. Used mainly for css3
         getPrefix: (prop) ->
+
+            # check if Moon already tried to get this prefix
+            if Moon.fn._prefixes[prop]?
+                return Moon.fn._prefixes[prop]
+
+            # if not, continue the search for it
             prefixes = ["webkit", "moz", "ms", "O"]
+
             indexOfDash = prop.indexOf("-")
             while indexOfDash > -1
+
                 # the letter after the dash is capitalized
                 prop = prop.slice(0, indexOfDash) + prop.charAt(indexOfDash + 1).toUpperCase() + prop.slice(indexOfDash + 2)
                 indexOfDash = prop.indexOf("-")
 
+            # is the propertie avaiable without prefix?
             if document.documentElement.style[prop]?
+                Moon.fn._prefixes[prop] = prop
                 return prop
 
+            # if not, try to find the prefix
+            propCap = Moon.fn.cap(prop)
             for pre in prefixes
-                propertie = pre + Moon.fn.cap(prop)
+                propertie = pre + propCap
                 if document.documentElement.style[propertie]?
+                    Moon.fn._prefixes[prop] = propertie
                     return propertie
-            
 
         # capitalizes the first letter
         cap: (str) ->

            for arg, value of args
                animationProps[arg] = value

            self._stack.push(animationProps)
            return self

        # play the animation and sets the end callback
        play: (callback) ->
            self = this
            self._callback = callback
            self._play()
            return self

        # "private" play function for intern use
        _play: ->
            self = this
            self._step++
            anm = self._stack[self._step]
            if anm?
                # before animation function
                anm.beforeAnimation() if typeof anm.beforeAnimation == "function"

                # apply animation for each element
                for el in self._collection
                    el.style[self.getPrefix("transition")] = "#{anm.duration}ms all #{anm.easing} #{anm.delay}ms"

                    for key, value of anm
                        if key == "duration" || key == "delay" || key == "easing" || key == "beforeAnimation" || key == "afterAnimation"
                            continue
                        el.style[self.getPrefix(key)] = value
                            
                nextTimeout = setTimeout ->
                    # after animation function
                    anm.afterAnimation() if typeof anm.afterAnimation == "function"

                    # continue chained animations
                    self._play()

                    clearTimeout(nextTimeout)
                , anm.delay + anm.duration

            # no more stacked animations
            else
                self._callback() if self._callback?

                # reset Moon animation
                self._callback = undefined
                self._step = -1
                self._stack = []

            return self

    window.Moon = Moon

        # defines an animation step. Moon animations must have at least one step
        animate: (args) ->
            animationProps =
                duration: 0
                delay: 0
