diff --git a/src/clj_pebble/core.clj b/src/clj_pebble/core.clj
index a1c4e2a..8354c3f 100644
--- a/src/clj_pebble/core.clj
+++ b/src/clj_pebble/core.clj
@@ -3,62 +3,35 @@
            (java.util Map)
            (com.mitchellbosecke.pebble PebbleEngine)
            (com.mitchellbosecke.pebble.loader ClasspathLoader FileLoader StringLoader)
-           (com.mitchellbosecke.pebble.template PebbleTemplate)
-           (com.mitchellbosecke.pebble.extension Function Filter Test))
-  (:require [clojure.walk :refer [stringify-keys]]))
+           (com.mitchellbosecke.pebble.template PebbleTemplate))
+  (:require [clojure.walk :refer [stringify-keys]]
+            [clj-pebble.extensions :as ext]
+            [clj-pebble.standard-extensions :as std]))
 
 (defonce classpath-loader (ClasspathLoader.))
 (defonce file-loader (FileLoader.))
 (defonce string-loader (StringLoader.))
 
 (defn- make-pebble-engine []
-  (PebbleEngine. classpath-loader))
+  (-> (PebbleEngine. classpath-loader)
+      (ext/add-extensions-library! std/extensions)))
 
 (defonce engine (atom (make-pebble-engine)))
 
 (defn reset-engine! []
   (reset! engine (make-pebble-engine)))
 
-(defn- get-sorted-args [args-map]
-  (->> args-map
-       (map
-         (fn [[k v]]
-           [(Integer/parseInt k) v]))
-       (sort-by first)
-       (map second)))
-
-(defn make-function [f]
-  (reify Function
-    (getArgumentNames [_] nil)
-    (execute [_ args]
-      (apply f (get-sorted-args args)))))
-
-(defn make-filter [f]
-  (reify Filter
-    (getArgumentNames [_] nil)
-    (apply [_ input args]
-      (apply f (concat [input] (get-sorted-args args))))))
-
-(defn make-test [f]
-  (reify Test
-    (getArgumentNames [_] nil)
-    (apply [_ input args]
-      (boolean (apply f (concat [input] (get-sorted-args args)))))))
-
 (defmacro defpebblefn [fn-name args & body]
-  `(let [f#         (fn ~args ~@body)
-         pebble-fn# (make-function f#)]
-     (.put (.getFunctions @engine) ~fn-name pebble-fn#)))
+  `(let [f# (fn ~args ~@body)]
+     (ext/add-function! @engine ~fn-name f#)))
 
 (defmacro defpebblefilter [filter-name args & body]
-  `(let [f#         (fn ~args ~@body)
-         pebble-fn# (make-filter f#)]
-     (.put (.getFilters @engine) ~filter-name pebble-fn#)))
+  `(let [f# (fn ~args ~@body)]
+     (ext/add-filter! @engine ~filter-name f#)))
 
 (defmacro defpebbletest [test-name args & body]
-  `(let [f#         (fn ~args ~@body)
-         pebble-fn# (make-test f#)]
-     (.put (.getTests @engine) ~test-name pebble-fn#)))
+  `(let [f# (fn ~args ~@body)]
+     (ext/add-test! @engine ~test-name f#)))
 
 (defn- prepare-context-map [context]
   (if context
diff --git a/src/clj_pebble/extensions.clj b/src/clj_pebble/extensions.clj
new file mode 100644
index 0000000..38dddc7
--- /dev/null
+++ b/src/clj_pebble/extensions.clj
@@ -0,0 +1,48 @@
+(ns clj-pebble.extensions
+  (:import (java.util Map)
+           (com.mitchellbosecke.pebble PebbleEngine)
+           (com.mitchellbosecke.pebble.extension Function Filter Test)))
+
+(defn- get-sorted-args [args-map]
+  (->> args-map
+       (map
+         (fn [[k v]]
+           [(Integer/parseInt k) v]))
+       (sort-by first)
+       (map second)))
+
+(defn make-function [f]
+  (reify Function
+    (getArgumentNames [_] nil)
+    (execute [_ args]
+      (apply f (get-sorted-args args)))))
+
+(defn make-filter [f]
+  (reify Filter
+    (getArgumentNames [_] nil)
+    (apply [_ input args]
+      (apply f (concat [input] (get-sorted-args args))))))
+
+(defn make-test [f]
+  (reify Test
+    (getArgumentNames [_] nil)
+    (apply [_ input args]
+      (boolean (apply f (concat [input] (get-sorted-args args)))))))
+
+(defn add-function! [^PebbleEngine engine ^String name f]
+  (.put (.getFunctions engine) name (make-function f)))
+
+(defn add-filter! [^PebbleEngine engine ^String name f]
+  (.put (.getFilters engine) name (make-filter f)))
+
+(defn add-test! [^PebbleEngine engine ^String name f]
+  (.put (.getTests engine) name (make-test f)))
+
+(defn add-extensions-library! [^PebbleEngine engine {:keys [functions filters tests]}]
+  (doseq [[name func] functions]
+    (add-function! engine name func))
+  (doseq [[name func] filters]
+    (add-filter! engine name func))
+  (doseq [[name func] tests]
+    (add-test! engine name func))
+  engine)
\ No newline at end of file