diff --git a/.gitignore b/.gitignore
index afc99012..28b34b00 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,4 @@
 target
 Cargo.lock
 *.bk
+src/ffi.rs
diff --git a/.gitmodules b/.gitmodules
new file mode 100644
index 00000000..e720ca7c
--- /dev/null
+++ b/.gitmodules
@@ -0,0 +1,3 @@
+[submodule "unqlite"]
+	path = unqlite
+	url = https://github.com/symisc/unqlite.git
diff --git a/Cargo.toml b/Cargo.toml
index 9be817a5..2a1c80fd 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,18 +1,21 @@
 [package]
 name = "unqlite"
-version = "1.3.2"
+version = "1.4.0"
 authors = ["Huo Linhe <huolinhe@berrygenomics.com>"]
 license = "MIT/Apache-2.0"
 readme  = "README.md"
 homepage = "https://github.com/zitsen/unqlite.rs"
 repository = "https://github.com/zitsen/unqlite.rs.git"
-documentation = "http://zitsen.github.io/unqlite.rs"
+documentation = "https://docs.rs/unqlite"
 description = "Rust `unqlite` library wrapper."
 keywords = ["unqlite", "kv", "nosql"]
 
+[build-dependencies]
+bindgen = "0.32"
+cc = "1.0"
+
 [dependencies]
 libc = "0.2"
-unqlite-sys = "^1.1.0"
 
 [dev-dependencies]
 tempfile = "2.1.3"
@@ -20,9 +23,9 @@ tempfile = "2.1.3"
 [features]
 default = ["enable-threads"]
 # For thread-safe
-enable-threads = [ "unqlite-sys/enable-threads" ]
+enable-threads = []
 # Other features
-jx9-disable-builtin-func = [ "unqlite-sys/jx9-disable-builtin-func" ]
-jx9-enable-math-func = [ "unqlite-sys/jx9-enable-math-func" ]
-jx9-disable-disk-io = [ "unqlite-sys/jx9-disable-disk-io" ]
-enable-jx9-hash-io = [ "unqlite-sys/enable-jx9-hash-io" ]
+jx9-disable-builtin-func = []
+jx9-enable-math-func = []
+jx9-disable-disk-io = []
+enable-jx9-hash-io = []
diff --git a/build.rs b/build.rs
new file mode 100644
index 00000000..dc1320ee
--- /dev/null
+++ b/build.rs
@@ -0,0 +1,70 @@
+extern crate bindgen;
+extern crate cc;
+
+fn main() {
+    use bindgen::builder;
+    // Configure and generate bindings.
+    let bindings = builder()
+        .header("unqlite/unqlite.h")
+        .with_codegen_config(bindgen::CodegenConfig {
+            vars: false,
+            ..Default::default()
+        })
+        .generate()
+        .expect("generate unqlite bindings");
+    // Write the generated bindings to an output file.
+    bindings
+        .write_to_file("src/ffi.rs")
+        .expect("write to source file");
+
+    cc::Build::new()
+        .file("unqlite/unqlite.c")
+        .warnings(false)
+        .if_enable_threads()
+        .if_jx9_diable_builtin_func()
+        .if_jx9_enable_math_func()
+        .if_jx9_disable_disk_io()
+        .if_enable_jx9_hash_io()
+        .compile("libunqlite.a");
+}
+trait ConfigExt {
+    fn if_enable_threads(&mut self) -> &mut Self {
+        self
+    }
+    fn if_jx9_diable_builtin_func(&mut self) -> &mut Self {
+        self
+    }
+    fn if_jx9_enable_math_func(&mut self) -> &mut Self {
+        self
+    }
+    fn if_jx9_disable_disk_io(&mut self) -> &mut Self {
+        self
+    }
+    fn if_enable_jx9_hash_io(&mut self) -> &mut Self {
+        self
+    }
+}
+
+impl ConfigExt for cc::Build {
+    #[cfg(feature = "enable-threads")]
+    fn if_enable_threads(&mut self) -> &mut Self {
+        self.define("UNQLITE_ENABLE_THREADS", None)
+            .flag("-lpthread")
+    }
+    #[cfg(feature = "jx9-disable-builtin-func")]
+    fn if_jx9_diable_builtin_func(&mut self) -> &mut Self {
+        self.define("JX9_DISABLE_BUILTIN_FUNC", None)
+    }
+    #[cfg(feature = "jx9-enable-math-func")]
+    fn if_jx9_enable_math_func(&mut self) -> &mut Self {
+        self.define("JX9_ENABLE_MATH_FUNC", None)
+    }
+    #[cfg(feature = "jx9-disable-disk-io")]
+    fn if_jx9_disable_disk_io(&mut self) -> &mut Self {
+        self.define("JX9_DISABLE_DISK_IO", None)
+    }
+    #[cfg(feature = "enable-jx9-hash-io")]
+    fn if_enable_jx9_hash_io(&mut self) -> &mut Self {
+        self.define("UNQLITE_ENABLE_JX9_HASH_IO", None)
+    }
+}
diff --git a/src/config.rs b/src/config.rs
index 028bdc7a..213fc223 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -1,14 +1,13 @@
 use UnQLite;
 use error::Wrap;
-use ffi::constants::{UNQLITE_CONFIG_JX9_ERR_LOG, UNQLITE_CONFIG_DISABLE_AUTO_COMMIT,
-                     UNQLITE_CONFIG_ERR_LOG, UNQLITE_CONFIG_GET_KV_NAME, UNQLITE_CONFIG_KV_ENGINE,
-                     UNQLITE_CONFIG_MAX_PAGE_CACHE};
 use ffi::unqlite_config;
 use libc::strlen;
 use std::ffi::CString;
 use std::mem;
 use std::os::raw::c_char;
 use std::ptr;
+use vars::{UNQLITE_CONFIG_JX9_ERR_LOG, UNQLITE_CONFIG_DISABLE_AUTO_COMMIT, UNQLITE_CONFIG_ERR_LOG,
+           UNQLITE_CONFIG_GET_KV_NAME, UNQLITE_CONFIG_KV_ENGINE, UNQLITE_CONFIG_MAX_PAGE_CACHE};
 
 /// A `Trait` for configuration.
 ///
@@ -153,7 +152,6 @@ fn from_chars_to_string(p: *mut c_char) -> String {
     from_chars_to_cstring(p).into_string().unwrap()
 }
 
-
 #[cfg(test)]
 #[cfg(feature = "enable-threads")]
 mod tests {
diff --git a/src/document/doc_store.rs b/src/document/doc_store.rs
index e092d066..aed0da93 100644
--- a/src/document/doc_store.rs
+++ b/src/document/doc_store.rs
@@ -6,11 +6,6 @@ use ffi::{unqlite_array_add_strkey_elem, unqlite_compile, unqlite_compile_file,
           unqlite_vm, unqlite_vm_config, unqlite_vm_dump, unqlite_vm_exec,
           unqlite_vm_extract_variable, unqlite_vm_new_array, unqlite_vm_new_scalar,
           unqlite_vm_release, unqlite_vm_release_value, unqlite_vm_reset, unqlite_value_int64};
-use ffi::constants::{UNQLITE_OK, UNQLITE_VM_CONFIG_ARGV_ENTRY, UNQLITE_VM_CONFIG_CREATE_VAR,
-                     UNQLITE_VM_CONFIG_ENV_ATTR, UNQLITE_VM_CONFIG_ERR_REPORT,
-                     UNQLITE_VM_CONFIG_EXEC_VALUE, UNQLITE_VM_CONFIG_EXTRACT_OUTPUT,
-                     UNQLITE_VM_CONFIG_IMPORT_PATH, UNQLITE_VM_CONFIG_OUTPUT,
-                     UNQLITE_VM_CONFIG_RECURSION_DEPTH, UNQLITE_VM_OUTPUT_LENGTH};
 use std::cell::RefCell;
 use std::ffi::CString;
 use std::os::raw::c_void;
@@ -18,6 +13,10 @@ use std::ptr::{null, null_mut, NonNull};
 use std::rc::Rc;
 use std::slice;
 use std::sync::mpsc;
+use vars::{UNQLITE_OK, UNQLITE_VM_CONFIG_ARGV_ENTRY, UNQLITE_VM_CONFIG_CREATE_VAR,
+           UNQLITE_VM_CONFIG_ENV_ATTR, UNQLITE_VM_CONFIG_ERR_REPORT, UNQLITE_VM_CONFIG_EXEC_VALUE,
+           UNQLITE_VM_CONFIG_EXTRACT_OUTPUT, UNQLITE_VM_CONFIG_IMPORT_PATH,
+           UNQLITE_VM_CONFIG_OUTPUT, UNQLITE_VM_CONFIG_RECURSION_DEPTH, UNQLITE_VM_OUTPUT_LENGTH};
 
 /// Jx9 script compiler Interface.
 ///
@@ -148,9 +147,7 @@ impl UnQLiteVm {
             UNQLITE_VM_CONFIG_EXTRACT_OUTPUT,
             &ptr,
             &mut len
-        ).map(|_| unsafe {
-            slice::from_raw_parts(ptr as *const u8, len as usize)
-        })
+        ).map(|_| unsafe { slice::from_raw_parts(ptr as *const u8, len as usize) })
     }
 
     /// Return the total number of bytes that have been outputted by the Virtual Machine
diff --git a/src/document/tests.rs b/src/document/tests.rs
index ce466a7d..0d3c6802 100644
--- a/src/document/tests.rs
+++ b/src/document/tests.rs
@@ -74,9 +74,8 @@ fn output_extract() {
     db.compile(prog)
         .and_then(|mut vm| {
             vm.exec().and_then(|_| {
-                vm.extract_output().map(|msg| {
-                    assert_eq!("hello world", String::from_utf8_lossy(msg))
-                })
+                vm.extract_output()
+                    .map(|msg| assert_eq!("hello world", String::from_utf8_lossy(msg)))
             })
         })
         .unwrap();
diff --git a/src/document/vm_value.rs b/src/document/vm_value.rs
index caae46ca..6dd25946 100644
--- a/src/document/vm_value.rs
+++ b/src/document/vm_value.rs
@@ -3,10 +3,10 @@ use ffi::{unqlite_array_count, unqlite_array_walk, unqlite_value, unqlite_value_
           unqlite_value_is_json_object, unqlite_value_is_null, unqlite_value_is_string,
           unqlite_value_to_bool, unqlite_value_to_double, unqlite_value_to_string,
           unqlite_value_to_int64};
-use ffi::constants::{UNQLITE_ABORT, UNQLITE_OK};
 use std::collections::HashMap;
 use std::os::raw::{c_int, c_void};
 use std::slice;
+use vars::{UNQLITE_ABORT, UNQLITE_OK};
 
 /// Map of Values
 pub type Map = HashMap<String, Value>;
@@ -153,7 +153,7 @@ unsafe extern "C" fn map_walk(
     match both {
         Some((k, v)) => {
             (*collection).insert(k, v);
-            UNQLITE_OK
+            UNQLITE_OK as _
         }
         None => UNQLITE_ABORT,
     }
diff --git a/src/error.rs b/src/error.rs
index b9be3ee9..7507f1d2 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -1,7 +1,7 @@
-use ffi::constants::*;
 use std::error;
 use std::fmt;
 use std::result;
+use vars::*;
 
 /// Custom `Result` type.
 pub type Result<T> = result::Result<T, Error>;
@@ -155,16 +155,7 @@ impl From<i32> for ErrorKind {
 /// ```
 ///
 /// This should be nice for functional programming style.
-///
-/// NOTE: Do not use this trait out of the crate
-///
-/// TODO: [`pub_restricted` feature][rfc_1422] is for the case,
-/// but [rsutfmt] will cause a panic if we use it now,
-/// we would apply this feature after [rustfmt][rustfmt] support it.
-///
-/// [rfc_1422]: https://github.com/rust-lang/rfcs/blob/master/text/1422-pub-restricted.md
-/// [rustfmt]: https://github.com/rust-lang-nursery/rustfmt
-pub trait Wrap {
+pub(crate) trait Wrap {
     fn wrap(self) -> Result<()>;
 }
 
@@ -179,12 +170,10 @@ impl Custom {
         let kind = ErrorKind::from(result);
         match kind {
             ErrorKind::OK => Ok(()),
-            _ => Err(
-                Custom {
-                    kind: kind,
-                    raw: result,
-                }.into(),
-            ),
+            _ => Err(Custom {
+                kind: kind,
+                raw: result,
+            }.into()),
         }
     }
 
diff --git a/src/kv_cursor.rs b/src/kv_cursor.rs
index 9be2da0f..85ec2464 100644
--- a/src/kv_cursor.rs
+++ b/src/kv_cursor.rs
@@ -5,10 +5,10 @@ use ffi::{unqlite, unqlite_kv_cursor, unqlite_kv_cursor_data, unqlite_kv_cursor_
           unqlite_kv_cursor_key, unqlite_kv_cursor_key_callback, unqlite_kv_cursor_last_entry,
           unqlite_kv_cursor_next_entry, unqlite_kv_cursor_prev_entry, unqlite_kv_cursor_release,
           unqlite_kv_cursor_reset, unqlite_kv_cursor_seek, unqlite_kv_cursor_valid_entry};
-use ffi::constants::{UNQLITE_CURSOR_MATCH_EXACT, UNQLITE_CURSOR_MATCH_GE, UNQLITE_CURSOR_MATCH_LE};
 use std::mem;
 use std::os::raw::c_void;
 use std::ptr::{self, NonNull};
+use vars::{UNQLITE_CURSOR_MATCH_EXACT, UNQLITE_CURSOR_MATCH_GE, UNQLITE_CURSOR_MATCH_LE};
 
 /// Cursor iterator interfaces.
 ///
@@ -150,7 +150,6 @@ impl Entry {
         self.0.value_callback(func, data)
     }
 
-
     /// Goto next entry.
     ///
     /// Returns `None` if there's no valid cursors.
@@ -208,11 +207,9 @@ impl RawCursor {
     /// Opening Database Cursors
     pub fn init(unqlite: &UnQLite) -> Result<Self> {
         let mut cursor: *mut unqlite_kv_cursor = unsafe { mem::uninitialized() };
-        wrap!(init, unqlite.as_raw_mut_ptr(), &mut cursor).map(|_| {
-            RawCursor {
-                engine: unqlite.engine,
-                cursor: unsafe { NonNull::new_unchecked(cursor) },
-            }
+        wrap!(init, unqlite.as_raw_mut_ptr(), &mut cursor).map(|_| RawCursor {
+            engine: unqlite.engine,
+            cursor: unsafe { NonNull::new_unchecked(cursor) },
         })
     }
 
@@ -278,9 +275,8 @@ impl RawCursor {
 
         self.key_len().and_then(|mut len| {
             let ptr = unsafe { ::libc::malloc(len as _) };
-            wrap!(key, self.cursor(), ptr as _, &mut len).map(|_| unsafe {
-                Vec::from_raw_parts(ptr as _, len as _, len as _)
-            })
+            wrap!(key, self.cursor(), ptr as _, &mut len)
+                .map(|_| unsafe { Vec::from_raw_parts(ptr as _, len as _, len as _) })
         })
     }
 
@@ -297,9 +293,8 @@ impl RawCursor {
 
         self.value_len().and_then(|mut len| {
             let ptr = unsafe { ::libc::malloc(len as _) };
-            wrap!(data, self.cursor(), ptr as _, &mut len).map(|_| unsafe {
-                Vec::from_raw_parts(ptr as _, len as _, len as _)
-            })
+            wrap!(data, self.cursor(), ptr as _, &mut len)
+                .map(|_| unsafe { Vec::from_raw_parts(ptr as _, len as _, len as _) })
         })
     }
 
@@ -316,7 +311,6 @@ impl RawCursor {
             .and_then(|key| self.value().map(|value| (key, value)))
     }
 
-
     /// Deleting Records using Database Cursors
     pub fn delete(self) -> Result<Self> {
         wrap_in_place!(self, delete_entry)
diff --git a/src/kv_store.rs b/src/kv_store.rs
index 65a1f47e..d1c84cb8 100644
--- a/src/kv_store.rs
+++ b/src/kv_store.rs
@@ -8,10 +8,10 @@ use ffi::{unqlite_kv_append,
           unqlite_kv_fetch,
           unqlite_kv_fetch_callback,
           unqlite_kv_store};
-use ffi::constants::{UNQLITE_KV_CONFIG_CMP_FUNC, UNQLITE_KV_CONFIG_HASH_FUNC};
 use std::mem;
 use std::os::raw::c_void;
 use std::ptr;
+use vars::{UNQLITE_KV_CONFIG_CMP_FUNC, UNQLITE_KV_CONFIG_HASH_FUNC};
 
 /// Key-Value Store Interface
 pub trait KV {
diff --git a/src/lib.rs b/src/lib.rs
index fa938fa3..be26770c 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -78,13 +78,13 @@
 #![feature(concat_idents)]
 
 extern crate libc;
-extern crate unqlite_sys as ffi;
 
 #[cfg(test)]
 extern crate tempfile;
 
 pub use error::{Error, Result};
 use error::Wrap;
+
 use ffi::{unqlite_close, unqlite_open};
 use std::ffi::CString;
 use std::mem;
@@ -119,7 +119,6 @@ macro_rules! wrap {
     ($i: ident, $($e: expr),*) => (eval!($i, $($e),*).wrap());
 }
 
-
 macro_rules! wrap_raw {
     ($self_:ident, $i: ident) => (
         wrap!($i, $self_.as_raw_mut_ptr())
@@ -141,10 +140,8 @@ impl UnQLite {
         let mut db: *mut ::ffi::unqlite = unsafe { mem::uninitialized() };
         let filename = filename.as_ref();
         let filename = try!(CString::new(filename));
-        wrap!(open, &mut db, filename.as_ptr(), mode.into()).map(|_| {
-            UnQLite {
-                engine: unsafe { NonNull::new_unchecked(db) },
-            }
+        wrap!(open, &mut db, filename.as_ptr(), mode.into()).map(|_| UnQLite {
+            engine: unsafe { NonNull::new_unchecked(db) },
         })
     }
 
@@ -270,6 +267,11 @@ impl Drop for UnQLite {
     }
 }
 
+#[allow(dead_code, non_snake_case, non_camel_case_types)]
+mod ffi;
+#[allow(dead_code)]
+mod vars;
+
 mod error;
 mod openmode;
 mod config;
diff --git a/src/openmode.rs b/src/openmode.rs
index 1add41b6..32686a54 100644
--- a/src/openmode.rs
+++ b/src/openmode.rs
@@ -1,4 +1,3 @@
-use ffi::constants;
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum OpenMode {
     ReadOnly,
@@ -17,15 +16,15 @@ pub use self::OpenMode::*;
 impl Into<u32> for OpenMode {
     fn into(self) -> u32 {
         match self {
-            ReadOnly => constants::UNQLITE_OPEN_READONLY,
-            // ReadWrite => constants::UNQLITE_OPEN_READWRITE,
-            Create => constants::UNQLITE_OPEN_CREATE,
-            // Exclusive => constants::UNQLITE_OPEN_EXCLUSIVE,
-            TempDB => constants::UNQLITE_OPEN_TEMP_DB,
-            // NoMutex => constants::UNQLITE_OPEN_NOMUTEX,
-            // OmitJournaling => constants::UNQLITE_OPEN_OMIT_JOURNALING,
-            // InMemory => constants::UNQLITE_OPEN_IN_MEMORY,
-            MMap => constants::UNQLITE_OPEN_MMAP | constants::UNQLITE_OPEN_READONLY,
+            ReadOnly => ::vars::UNQLITE_OPEN_READONLY,
+            // ReadWrite => vars::UNQLITE_OPEN_READWRITE,
+            Create => ::vars::UNQLITE_OPEN_CREATE,
+            // Exclusive =>vars::UNQLITE_OPEN_EXCLUSIVE,
+            TempDB => ::vars::UNQLITE_OPEN_TEMP_DB,
+            // NoMutex =>vars::UNQLITE_OPEN_NOMUTEX,
+            // OmitJournaling =>vars::UNQLITE_OPEN_OMIT_JOURNALING,
+            // InMemory =>vars::UNQLITE_OPEN_IN_MEMORY,
+            MMap => ::vars::UNQLITE_OPEN_MMAP | ::vars::UNQLITE_OPEN_READONLY,
         }
     }
 }
diff --git a/src/util.rs b/src/util.rs
index 4d26f54b..e65ba69b 100644
--- a/src/util.rs
+++ b/src/util.rs
@@ -50,11 +50,9 @@ pub fn load_mmaped_file<P: AsRef<Path>>(path: P) -> Result<Mmap> {
         ));
         unqlite_util_load_mmaped_file(cpath.as_ptr(), &mut ptr, &mut size)
             .wrap()
-            .map(|_| {
-                Mmap {
-                    ptr: ptr,
-                    size: size,
-                }
+            .map(|_| Mmap {
+                ptr: ptr,
+                size: size,
             })
     }
 }
diff --git a/src/vars.rs b/src/vars.rs
new file mode 100644
index 00000000..dbb6ac02
--- /dev/null
+++ b/src/vars.rs
@@ -0,0 +1,123 @@
+/* automatically generated by rust-bindgen */
+
+pub const UNQLITE_VERSION: &'static [u8; 6usize] = b"1.1.8\0";
+pub const UNQLITE_VERSION_NUMBER: ::std::os::raw::c_int = 1001008;
+pub const UNQLITE_SIG: &'static [u8; 14usize] = b"unqlite/1.1.8\0";
+pub const UNQLITE_IDENT: &'static [u8; 49usize] =
+    b"unqlite:b172a1e2c3f62fb35c8e1fb2795121f82356cad6\0";
+pub const UNQLITE_COPYRIGHT : & 'static [ u8 ; 108usize ] = b"Copyright (C) Symisc Systems, S.U.A.R.L [Mrad Chems Eddine <chm@symisc.net>] 2012-2018, http://unqlite.org/\0" ;
+pub const SXRET_OK: ::std::os::raw::c_int = 0;
+pub const SXERR_MEM: ::std::os::raw::c_int = -1;
+pub const SXERR_IO: ::std::os::raw::c_int = -2;
+pub const SXERR_EMPTY: ::std::os::raw::c_int = -3;
+pub const SXERR_LOCKED: ::std::os::raw::c_int = -4;
+pub const SXERR_ORANGE: ::std::os::raw::c_int = -5;
+pub const SXERR_NOTFOUND: ::std::os::raw::c_int = -6;
+pub const SXERR_LIMIT: ::std::os::raw::c_int = -7;
+pub const SXERR_MORE: ::std::os::raw::c_int = -8;
+pub const SXERR_INVALID: ::std::os::raw::c_int = -9;
+pub const SXERR_ABORT: ::std::os::raw::c_int = -10;
+pub const SXERR_EXISTS: ::std::os::raw::c_int = -11;
+pub const SXERR_SYNTAX: ::std::os::raw::c_int = -12;
+pub const SXERR_UNKNOWN: ::std::os::raw::c_int = -13;
+pub const SXERR_BUSY: ::std::os::raw::c_int = -14;
+pub const SXERR_OVERFLOW: ::std::os::raw::c_int = -15;
+pub const SXERR_WILLBLOCK: ::std::os::raw::c_int = -16;
+pub const SXERR_NOTIMPLEMENTED: ::std::os::raw::c_int = -17;
+pub const SXERR_EOF: ::std::os::raw::c_int = -18;
+pub const SXERR_PERM: ::std::os::raw::c_int = -19;
+pub const SXERR_NOOP: ::std::os::raw::c_int = -20;
+pub const SXERR_FORMAT: ::std::os::raw::c_int = -21;
+pub const SXERR_NEXT: ::std::os::raw::c_int = -22;
+pub const SXERR_OS: ::std::os::raw::c_int = -23;
+pub const SXERR_CORRUPT: ::std::os::raw::c_int = -24;
+pub const SXERR_CONTINUE: ::std::os::raw::c_int = -25;
+pub const SXERR_NOMATCH: ::std::os::raw::c_int = -26;
+pub const SXERR_RESET: ::std::os::raw::c_int = -27;
+pub const SXERR_DONE: ::std::os::raw::c_int = -28;
+pub const SXERR_SHORT: ::std::os::raw::c_int = -29;
+pub const SXERR_PATH: ::std::os::raw::c_int = -30;
+pub const SXERR_TIMEOUT: ::std::os::raw::c_int = -31;
+pub const SXERR_BIG: ::std::os::raw::c_int = -32;
+pub const SXERR_RETRY: ::std::os::raw::c_int = -33;
+pub const SXERR_IGNORE: ::std::os::raw::c_int = -63;
+pub const UNQLITE_OK: ::std::os::raw::c_int = 0;
+pub const UNQLITE_NOMEM: ::std::os::raw::c_int = -1;
+pub const UNQLITE_ABORT: ::std::os::raw::c_int = -10;
+pub const UNQLITE_IOERR: ::std::os::raw::c_int = -2;
+pub const UNQLITE_CORRUPT: ::std::os::raw::c_int = -24;
+pub const UNQLITE_LOCKED: ::std::os::raw::c_int = -4;
+pub const UNQLITE_BUSY: ::std::os::raw::c_int = -14;
+pub const UNQLITE_DONE: ::std::os::raw::c_int = -28;
+pub const UNQLITE_PERM: ::std::os::raw::c_int = -19;
+pub const UNQLITE_NOTIMPLEMENTED: ::std::os::raw::c_int = -17;
+pub const UNQLITE_NOTFOUND: ::std::os::raw::c_int = -6;
+pub const UNQLITE_NOOP: ::std::os::raw::c_int = -20;
+pub const UNQLITE_INVALID: ::std::os::raw::c_int = -9;
+pub const UNQLITE_EOF: ::std::os::raw::c_int = -18;
+pub const UNQLITE_UNKNOWN: ::std::os::raw::c_int = -13;
+pub const UNQLITE_LIMIT: ::std::os::raw::c_int = -7;
+pub const UNQLITE_EXISTS: ::std::os::raw::c_int = -11;
+pub const UNQLITE_EMPTY: ::std::os::raw::c_int = -3;
+pub const UNQLITE_COMPILE_ERR: ::std::os::raw::c_int = -70;
+pub const UNQLITE_VM_ERR: ::std::os::raw::c_int = -71;
+pub const UNQLITE_FULL: ::std::os::raw::c_int = -73;
+pub const UNQLITE_CANTOPEN: ::std::os::raw::c_int = -74;
+pub const UNQLITE_READ_ONLY: ::std::os::raw::c_int = -75;
+pub const UNQLITE_LOCKERR: ::std::os::raw::c_int = -76;
+pub const UNQLITE_CONFIG_JX9_ERR_LOG: ::std::os::raw::c_int = 1;
+pub const UNQLITE_CONFIG_MAX_PAGE_CACHE: ::std::os::raw::c_int = 2;
+pub const UNQLITE_CONFIG_ERR_LOG: ::std::os::raw::c_int = 3;
+pub const UNQLITE_CONFIG_KV_ENGINE: ::std::os::raw::c_int = 4;
+pub const UNQLITE_CONFIG_DISABLE_AUTO_COMMIT: ::std::os::raw::c_int = 5;
+pub const UNQLITE_CONFIG_GET_KV_NAME: ::std::os::raw::c_int = 6;
+pub const UNQLITE_VM_CONFIG_OUTPUT: ::std::os::raw::c_int = 1;
+pub const UNQLITE_VM_CONFIG_IMPORT_PATH: ::std::os::raw::c_int = 2;
+pub const UNQLITE_VM_CONFIG_ERR_REPORT: ::std::os::raw::c_int = 3;
+pub const UNQLITE_VM_CONFIG_RECURSION_DEPTH: ::std::os::raw::c_int = 4;
+pub const UNQLITE_VM_OUTPUT_LENGTH: ::std::os::raw::c_int = 5;
+pub const UNQLITE_VM_CONFIG_CREATE_VAR: ::std::os::raw::c_int = 6;
+pub const UNQLITE_VM_CONFIG_HTTP_REQUEST: ::std::os::raw::c_int = 7;
+pub const UNQLITE_VM_CONFIG_SERVER_ATTR: ::std::os::raw::c_int = 8;
+pub const UNQLITE_VM_CONFIG_ENV_ATTR: ::std::os::raw::c_int = 9;
+pub const UNQLITE_VM_CONFIG_EXEC_VALUE: ::std::os::raw::c_int = 10;
+pub const UNQLITE_VM_CONFIG_IO_STREAM: ::std::os::raw::c_int = 11;
+pub const UNQLITE_VM_CONFIG_ARGV_ENTRY: ::std::os::raw::c_int = 12;
+pub const UNQLITE_VM_CONFIG_EXTRACT_OUTPUT: ::std::os::raw::c_int = 13;
+pub const UNQLITE_KV_CONFIG_HASH_FUNC: ::std::os::raw::c_int = 1;
+pub const UNQLITE_KV_CONFIG_CMP_FUNC: ::std::os::raw::c_int = 2;
+pub const UNQLITE_LIB_CONFIG_USER_MALLOC: ::std::os::raw::c_int = 1;
+pub const UNQLITE_LIB_CONFIG_MEM_ERR_CALLBACK: ::std::os::raw::c_int = 2;
+pub const UNQLITE_LIB_CONFIG_USER_MUTEX: ::std::os::raw::c_int = 3;
+pub const UNQLITE_LIB_CONFIG_THREAD_LEVEL_SINGLE: ::std::os::raw::c_int = 4;
+pub const UNQLITE_LIB_CONFIG_THREAD_LEVEL_MULTI: ::std::os::raw::c_int = 5;
+pub const UNQLITE_LIB_CONFIG_VFS: ::std::os::raw::c_int = 6;
+pub const UNQLITE_LIB_CONFIG_STORAGE_ENGINE: ::std::os::raw::c_int = 7;
+pub const UNQLITE_LIB_CONFIG_PAGE_SIZE: ::std::os::raw::c_int = 8;
+pub const UNQLITE_OPEN_READONLY: ::std::os::raw::c_uint = 1;
+pub const UNQLITE_OPEN_READWRITE: ::std::os::raw::c_uint = 2;
+pub const UNQLITE_OPEN_CREATE: ::std::os::raw::c_uint = 4;
+pub const UNQLITE_OPEN_EXCLUSIVE: ::std::os::raw::c_uint = 8;
+pub const UNQLITE_OPEN_TEMP_DB: ::std::os::raw::c_uint = 16;
+pub const UNQLITE_OPEN_NOMUTEX: ::std::os::raw::c_uint = 32;
+pub const UNQLITE_OPEN_OMIT_JOURNALING: ::std::os::raw::c_uint = 64;
+pub const UNQLITE_OPEN_IN_MEMORY: ::std::os::raw::c_uint = 128;
+pub const UNQLITE_OPEN_MMAP: ::std::os::raw::c_uint = 256;
+pub const UNQLITE_SYNC_NORMAL: ::std::os::raw::c_uint = 2;
+pub const UNQLITE_SYNC_FULL: ::std::os::raw::c_uint = 3;
+pub const UNQLITE_SYNC_DATAONLY: ::std::os::raw::c_uint = 16;
+pub const UNQLITE_LOCK_NONE: ::std::os::raw::c_uint = 0;
+pub const UNQLITE_LOCK_SHARED: ::std::os::raw::c_uint = 1;
+pub const UNQLITE_LOCK_RESERVED: ::std::os::raw::c_uint = 2;
+pub const UNQLITE_LOCK_PENDING: ::std::os::raw::c_uint = 3;
+pub const UNQLITE_LOCK_EXCLUSIVE: ::std::os::raw::c_uint = 4;
+pub const UNQLITE_ACCESS_EXISTS: ::std::os::raw::c_uint = 0;
+pub const UNQLITE_ACCESS_READWRITE: ::std::os::raw::c_uint = 1;
+pub const UNQLITE_ACCESS_READ: ::std::os::raw::c_uint = 2;
+pub const UNQLITE_CURSOR_MATCH_EXACT: ::std::os::raw::c_uint = 1;
+pub const UNQLITE_CURSOR_MATCH_LE: ::std::os::raw::c_uint = 2;
+pub const UNQLITE_CURSOR_MATCH_GE: ::std::os::raw::c_uint = 3;
+pub const UNQLITE_JOURNAL_FILE_SUFFIX: &'static [u8; 17usize] = b"_unqlite_journal\0";
+pub const UNQLITE_CTX_ERR: ::std::os::raw::c_uint = 1;
+pub const UNQLITE_CTX_WARNING: ::std::os::raw::c_uint = 2;
+pub const UNQLITE_CTX_NOTICE: ::std::os::raw::c_uint = 3;
diff --git a/unqlite b/unqlite
new file mode 160000
index 00000000..d3da0e10
--- /dev/null
+++ b/unqlite
@@ -0,0 +1 @@
+Subproject commit d3da0e10f0548dc4f85efdf6905203f6c7320a06