diff --git a/.cargo_vcs_info.json b/.cargo_vcs_info.json
new file mode 100644
index 0000000..6e425e4
--- /dev/null
+++ b/.cargo_vcs_info.json
@@ -0,0 +1,5 @@
+{
+  "git": {
+    "sha1": "3ded2f87af33e2ff8c722836ab0f35a98c11ec92"
+  }
+}
diff --git a/.github/workflows/libloading.yml b/.github/workflows/libloading.yml
new file mode 100644
index 0000000..2ba5d13
--- /dev/null
+++ b/.github/workflows/libloading.yml
@@ -0,0 +1,149 @@
+name: Test libloading
+
+on:
+  push:
+    paths-ignore:
+    - '*.mkd'
+    - 'LICENSE'
+  pull_request:
+    types: [opened, repoened, synchronize]
+
+jobs:
+  native-test:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        rust_toolchain: [nightly, stable, 1.40.0]
+        os: [ubuntu-latest, windows-latest, macOS-latest]
+    timeout-minutes: 20
+    steps:
+      - uses: actions/checkout@v2
+      - name: Install Rust ${{ matrix.rust_toolchain }}
+        uses: actions-rs/toolchain@v1
+        with:
+            toolchain: ${{ matrix.rust_toolchain }}
+            profile: minimal
+            default: true
+      - name: Update
+        uses: actions-rs/cargo@v1
+        with:
+          command: update
+          args: --manifest-path=Cargo.toml
+      - name: Build
+        uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: --manifest-path=Cargo.toml
+      - name: Test
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --manifest-path=Cargo.toml -- --nocapture
+      - name: Test Release
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --manifest-path=Cargo.toml --release -- --nocapture
+
+  windows-gnu-test:
+    runs-on: windows-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        rust_toolchain: [nightly, stable]
+        rust_target:
+          - x86_64-pc-windows-gnu
+          # Only 64 bit GCC is preinstalled
+          #- i686-pc-windows-gnu
+    steps:
+      - uses: actions/checkout@v2
+      - name: Install Rust nightly
+        uses: actions-rs/toolchain@v1
+        with:
+            toolchain: ${{ matrix.rust_toolchain }}
+            target: ${{ matrix.rust_target }}
+            profile: minimal
+            default: true
+      # https://github.com/rust-lang/rust/issues/49078
+      - name: Fix windows-gnu rust-mingw
+        run : |
+          for i in crt2.o dllcrt2.o libmingwex.a libmsvcrt.a ; do
+            cp -f "/C/ProgramData/Chocolatey/lib/mingw/tools/install/mingw64/x86_64-w64-mingw32/lib/$i" "`rustc --print sysroot`/lib/rustlib/x86_64-pc-windows-gnu/lib"
+          done
+        shell: bash
+      - uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: --target ${{ matrix.rust_target }} --manifest-path=Cargo.toml
+      - uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --target ${{ matrix.rust_target }} --manifest-path=Cargo.toml
+
+  bare-cross-build:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        rust_target:
+          # BSDs: could be tested with full system emulation
+          # - x86_64-unknown-dragonfly
+          # - x86_64-unknown-freebsd
+          - x86_64-unknown-haiku
+          # - x86_64-unknown-netbsd
+          - x86_64-unknown-openbsd
+          - x86_64-unknown-redox
+          - x86_64-fuchsia
+    timeout-minutes: 20
+    steps:
+      - uses: actions/checkout@v2
+      - name: Install Rust nightly
+        uses: actions-rs/toolchain@v1
+        with:
+            toolchain: nightly
+            profile: minimal
+            default: true
+      - name: Fix-up toolchain
+        run: |
+            rustup component add rust-src --toolchain nightly --target ${{ matrix.rust_target }}
+      - name: Update
+        uses: actions-rs/cargo@v1
+        with:
+          command: update
+          args: --manifest-path=Cargo.toml
+      - name: Build ${{ matrix.rust_target }}
+        uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: --target ${{ matrix.rust_target }} --manifest-path=Cargo.toml -Zbuild-std
+
+  cross-ios-build:
+    runs-on: macos-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        rust_toolchain: [nightly, stable]
+        rust_target:
+          - aarch64-apple-ios
+          - x86_64-apple-ios
+    timeout-minutes: 20
+    steps:
+      - uses: actions/checkout@v2
+      - name: Install Rust ${{ matrix.rust_toolchain }}
+        uses: actions-rs/toolchain@v1
+        with:
+            toolchain: ${{ matrix.rust_toolchain }}
+            target: ${{ matrix.rust_target }}
+            profile: minimal
+            default: true
+      - name: Update
+        uses: actions-rs/cargo@v1
+        with:
+          command: update
+          args: --manifest-path=Cargo.toml
+      - name: Build ${{ matrix.rust_target }}
+        uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: --target=${{ matrix.rust_target }} --manifest-path=Cargo.toml
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..241fb5a
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,3 @@
+target
+Cargo.lock
+doc
diff --git a/Android.bp b/Android.bp
new file mode 100644
index 0000000..1c74018
--- /dev/null
+++ b/Android.bp
@@ -0,0 +1,15 @@
+// This file is generated by cargo2android.py.
+
+rust_library_host_rlib {
+    name: "liblibloading",
+    crate_name: "libloading",
+    srcs: ["src/lib.rs"],
+    edition: "2015",
+    flags: [
+        "--cfg mtsafe_dlerror",
+    ],
+    // TODO: Cannot use libdl on Android host?
+    // shared_libs: [
+    //     "libdl",
+    // ],
+}
diff --git a/Cargo.toml b/Cargo.toml
new file mode 100644
index 0000000..7b80f9f
--- /dev/null
+++ b/Cargo.toml
@@ -0,0 +1,25 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies
+#
+# If you believe there's an error in this file please file an
+# issue against the rust-lang/cargo repository. If you're
+# editing this file be aware that the upstream Cargo.toml
+# will likely look very different (and much more reasonable)
+
+[package]
+name = "libloading"
+version = "0.6.1"
+authors = ["Simonas Kazlauskas <libloading@kazlauskas.me>"]
+build = "build.rs"
+description = "A safer binding to platform’s dynamic library loading utilities"
+documentation = "https://docs.rs/libloading/"
+keywords = ["dlopen", "load", "shared", "dylib"]
+license = "ISC"
+repository = "https://github.com/nagisa/rust_libloading/"
+[target."cfg(windows)".dependencies.winapi]
+version = "0.3"
+features = ["winerror", "errhandlingapi", "libloaderapi"]
diff --git a/Cargo.toml.orig b/Cargo.toml.orig
new file mode 100644
index 0000000..22e1845
--- /dev/null
+++ b/Cargo.toml.orig
@@ -0,0 +1,18 @@
+[package]
+name = "libloading"
+version = "0.6.1"
+authors = ["Simonas Kazlauskas <libloading@kazlauskas.me>"]
+build = "build.rs"
+description = "A safer binding to platform’s dynamic library loading utilities"
+keywords = ["dlopen", "load", "shared", "dylib"]
+license = "ISC"
+repository = "https://github.com/nagisa/rust_libloading/"
+documentation = "https://docs.rs/libloading/"
+
+[target.'cfg(windows)'.dependencies.winapi]
+version = "0.3"
+features = [
+    "winerror",
+    "errhandlingapi",
+    "libloaderapi",
+]
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..9137d56
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,12 @@
+Copyright © 2015, Simonas Kazlauskas
+
+Permission to use, copy, modify, and/or distribute this software for any purpose with or without
+fee is hereby granted, provided that the above copyright notice and this permission notice appear
+in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
+SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE.
diff --git a/METADATA b/METADATA
new file mode 100644
index 0000000..ce7ba3b
--- /dev/null
+++ b/METADATA
@@ -0,0 +1,19 @@
+name: "libloading"
+description: "A safer binding to platform\'s dynamic library loading utilities."
+third_party {
+  url {
+    type: HOMEPAGE
+    value: "https://crates.io/crates/libloading"
+  }
+  url {
+    type: GIT
+    value: "https://github.com/nagisa/rust_libloading"
+  }
+  version: "0.6.1"
+  license_type: NOTICE
+  last_upgrade_date {
+    year: 2020
+    month: 4
+    day: 16
+  }
+}
diff --git a/MODULE_LICENSE_BSD_LIKE b/MODULE_LICENSE_BSD_LIKE
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/MODULE_LICENSE_BSD_LIKE
diff --git a/OWNERS b/OWNERS
new file mode 100644
index 0000000..46fc303
--- /dev/null
+++ b/OWNERS
@@ -0,0 +1 @@
+include platform/prebuilts/rust:/OWNERS
diff --git a/README.mkd b/README.mkd
new file mode 100644
index 0000000..006f172
--- /dev/null
+++ b/README.mkd
@@ -0,0 +1,16 @@
+# libloading
+
+A memory-safer wrapper around system dynamic library loading primitives. The most important safety
+guarantee by this library is prevention of dangling-`Symbol`s that may occur after a `Library` is
+unloaded.
+
+Using this library allows loading dynamic libraries (also known as shared libraries) as well as use
+functions and static variables these libraries contain.
+
+* [Documentation][docs]
+* [Changelog][changelog]
+
+[docs]: https://docs.rs/libloading/
+[changelog]: https://docs.rs/libloading/*/libloading/changelog/index.html
+
+libloading is distributed under ISC (MIT-like) license.
diff --git a/build.rs b/build.rs
new file mode 100644
index 0000000..c41a14a
--- /dev/null
+++ b/build.rs
@@ -0,0 +1,64 @@
+use std::io::Write;
+use std::env;
+
+fn dlerror_is_mtsafe(target_os: &str) {
+    match target_os {
+        // Confirmed MT-safe:
+        "linux"
+        | "android"
+        | "openbsd"
+        | "macos"
+        | "ios"
+        | "solaris"
+        | "illumos"
+        | "redox"
+        | "fuchsia" => {
+            println!("cargo:rustc-cfg=mtsafe_dlerror");
+        }
+        // Confirmed not MT-safe:
+        "freebsd"
+        | "dragonfly"
+        | "netbsd"
+        | "bitrig"
+        | "haiku" => {}
+        // Unknown:
+        _ => {}
+    }
+}
+
+fn link_libraries(target_os: &str) {
+    match target_os {
+        "linux" | "android" => println!("cargo:rustc-link-lib=dl"),
+        "freebsd" | "dragonfly" => println!("cargo:rustc-link-lib=c"),
+        // netbsd claims dl* will be available to any dynamically linked binary, but I haven’t
+        // found any libraries that have to be linked to on other platforms.
+        // What happens if the executable is not linked up dynamically?
+        "openbsd" | "bitrig" | "netbsd" | "macos" | "ios" => {}
+        "solaris" => {}
+        "haiku" => {}
+        "redox" => {}
+        "fuchsia" => {}
+        // dependencies come with winapi
+        "windows" => {}
+        tos => {
+            writeln!(::std::io::stderr(),
+                     "Building for an unknown target_os=`{:?}`!\nPlease report an issue ",
+                     tos).expect("could not report the error");
+            ::std::process::exit(0xfc);
+        }
+    }
+}
+
+fn main() {
+    match env::var("CARGO_CFG_TARGET_OS") {
+        Ok(target_os) => {
+            dlerror_is_mtsafe(&target_os);
+            link_libraries(&target_os);
+        }
+        Err(e) => {
+            writeln!(::std::io::stderr(),
+                     "Unable to get target_os=`{}`!", e).expect("could not report the error");
+            ::std::process::exit(0xfd);
+        }
+    }
+}
diff --git a/src/changelog.rs b/src/changelog.rs
new file mode 100644
index 0000000..68b6c54
--- /dev/null
+++ b/src/changelog.rs
@@ -0,0 +1,143 @@
+//! Project changelog
+
+// TODO: for the next breaking release rename `Error::LoadLibraryW` to `Error::LoadLibraryExW`.
+
+/// Release 0.6.1 (2020-04-15)
+///
+/// * Introduced a new method [`os::windows::Library::load_with_flags`];
+/// * Added support for the Illumos triple.
+///
+/// [`os::windows::Library::load_with_flags`]: ../../os/windows/struct.Library.html#method.load_with_flags
+pub mod r0_6_1 {}
+
+/// Release 0.6.0 (2020-04-05)
+///
+/// * Introduced a new method [`os::unix::Library::get_singlethreaded`];
+/// * Added (untested) support for building when targetting Redox and Fuchsia;
+/// * The APIs exposed by this library no longer panic and instead return an `Err` when it used
+///   to panic.
+///
+/// ## Breaking changes
+///
+/// * Minimum required (stable) version of Rust to build this library is now 1.40.0;
+/// * This crate now implements a custom [`Error`] type and all APIs now return this type rather
+///   than returning the `std::io::Error`;
+/// * `libloading::Result` has been removed;
+/// * Removed the dependency on the C compiler to build this library on UNIX-like platforms.
+///   `libloading` used to utilize a snippet written in C to work-around the unlikely possibility
+///   of the target having a thread-unsafe implementation of the `dlerror` function. The effect of
+///   the work-around was very opportunistic: it would not work if the function was called by
+///   forgoing `libloading`.
+///
+///   Starting with 0.6.0, [`Library::get`] on platforms where `dlerror` is not MT-safe (such as
+///   FreeBSD, DragonflyBSD or NetBSD) will unconditionally return an error when the underlying
+///   `dlsym` returns a null pointer. For the use-cases where loading null pointers is necessary
+///   consider using [`os::unix::Library::get_singlethreaded`] instead.
+///
+/// [`Library::get`]: ../../struct.Library.html#method.get
+/// [`os::unix::Library::get_singlethreaded`]: ../../os/unix/struct.Library.html#method.get_singlethreaded
+/// [`Error`]: ../../enum.Error.html
+pub mod r0_6_0 {}
+
+
+/// Release 0.5.2 (2019-07-07)
+///
+/// * Added API to convert OS-specific `Library` and `Symbol` conversion to underlying resources.
+pub mod r0_5_2 {}
+
+/// Release 0.5.1 (2019-06-01)
+///
+/// * Build on Haiku targets.
+pub mod r0_5_1 {}
+
+/// Release 0.5.0 (2018-01-11)
+///
+/// * Update to `winapi = ^0.3`;
+///
+/// ## Breaking changes
+///
+/// * libloading now requires a C compiler to build on UNIX;
+///   * This is a temporary measure until the [`linkage`] attribute is stabilised;
+///   * Necessary to resolve [#32].
+///
+/// [`linkage`]: https://github.com/rust-lang/rust/issues/29603
+/// [#32]: https://github.com/nagisa/rust_libloading/issues/32
+pub mod r0_5_0 {}
+
+/// Release 0.4.3 (2017-12-07)
+///
+/// * Bump lazy-static dependency to `^1.0`;
+/// * `cargo test --release` now works when testing libloading.
+pub mod r0_4_3 {}
+
+
+/// Release 0.4.2 (2017-09-24)
+///
+/// * Improved error and race-condition handling on Windows;
+/// * Improved documentation about thread-safety of Library;
+/// * Added `Symbol::<Option<T>::lift_option() -> Option<Symbol<T>>` convenience method.
+pub mod r0_4_2 {}
+
+
+/// Release 0.4.1 (2017-08-29)
+///
+/// * Solaris support
+pub mod r0_4_1 {}
+
+/// Release 0.4.0 (2017-05-01)
+///
+/// * Remove build-time dependency on target_build_utils (and by extension serde/phf);
+/// * Require at least version 1.14.0 of rustc to build;
+///   * Actually, it is cargo which has to be more recent here. The one shipped with rustc 1.14.0
+///     is what’s being required from now on.
+pub mod r0_4_0 {}
+
+/// Release 0.3.4 (2017-03-25)
+///
+/// * Remove rogue println!
+pub mod r0_3_4 {}
+
+/// Release 0.3.3 (2017-03-25)
+///
+/// * Panics when `Library::get` is called for incompatibly sized type such as named function
+///   types (which are zero-sized).
+pub mod r0_3_3 {}
+
+/// Release 0.3.2 (2017-02-10)
+///
+/// * Minimum version required is now rustc 1.12.0;
+/// * Updated dependency versions (most notably target_build_utils to 0.3.0)
+pub mod r0_3_2 {}
+
+/// Release 0.3.1 (2016-10-01)
+///
+/// * `Symbol<T>` and `os::*::Symbol<T>` now implement `Send` where `T: Send`;
+/// * `Symbol<T>` and `os::*::Symbol<T>` now implement `Sync` where `T: Sync`;
+/// * `Library` and `os::*::Library` now implement `Sync` (they were `Send` in 0.3.0 already).
+pub mod r0_3_1 {}
+
+/// Release 0.3.0 (2016-07-27)
+///
+/// * Greatly improved documentation, especially around platform-specific behaviours;
+/// * Improved test suite by building our own library to test against;
+/// * All `Library`-ies now implement `Send`.
+/// * Added `impl From<os::platform::Library> for Library` and `impl From<Library> for
+/// os::platform::Library` allowing wrapping and extracting the platform-specific library handle;
+/// * Added methods to wrap (`Symbol::from_raw`) and unwrap (`Symbol::into_raw`) the safe `Symbol`
+/// wrapper into unsafe `os::platform::Symbol`.
+///
+/// The last two additions focus on not restricting potential usecases of this library, allowing
+/// users of the library to circumvent safety checks if need be.
+///
+/// ## Breaking Changes
+///
+/// `Library::new` defaults to `RTLD_NOW` instead of `RTLD_LAZY` on UNIX for more consistent
+/// cross-platform behaviour. If a library loaded with `Library::new` had any linking errors, but
+/// unresolved references weren’t forced to be resolved, the library would’ve “just worked”,
+/// whereas now the call to `Library::new` will return an error signifying presence of such error.
+///
+/// ## os::platform
+/// * Added `os::unix::Library::open` which allows specifying arbitrary flags (e.g. `RTLD_LAZY`);
+/// * Added `os::windows::Library::get_ordinal` which allows finding a function or variable by its
+/// ordinal number;
+pub mod r0_3_0 {}
diff --git a/src/error.rs b/src/error.rs
new file mode 100644
index 0000000..dcbe2b1
--- /dev/null
+++ b/src/error.rs
@@ -0,0 +1,114 @@
+use std::ffi::CString;
+
+pub struct DlDescription(pub(crate) CString);
+
+impl std::fmt::Debug for DlDescription {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        std::fmt::Debug::fmt(&self.0, f)
+    }
+}
+
+pub struct WindowsError(pub(crate) std::io::Error);
+
+impl std::fmt::Debug for WindowsError {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        std::fmt::Debug::fmt(&self.0, f)
+    }
+}
+
+#[derive(Debug)]
+#[non_exhaustive]
+pub enum Error {
+    /// The `dlopen` call failed.
+    DlOpen { desc: DlDescription },
+    /// The `dlopen` call failed and system did not report an error.
+    DlOpenUnknown,
+    /// The `dlsym` call failed.
+    DlSym { desc: DlDescription },
+    /// The `dlsym` call failed and system did not report an error.
+    DlSymUnknown,
+    /// The `dlclose` call failed.
+    DlClose { desc: DlDescription },
+    /// The `dlclose` call failed and system did not report an error.
+    DlCloseUnknown,
+    /// The `LoadLibraryW` call failed.
+    LoadLibraryW { source: WindowsError },
+    /// The `LoadLibraryW` call failed and system did not report an error.
+    LoadLibraryWUnknown,
+    /// The `GetProcAddress` call failed.
+    GetProcAddress { source: WindowsError },
+    /// The `GetProcAddressUnknown` call failed and system did not report an error.
+    GetProcAddressUnknown,
+    /// The `FreeLibrary` call failed.
+    FreeLibrary { source: WindowsError },
+    /// The `FreeLibrary` call failed and system did not report an error.
+    FreeLibraryUnknown,
+    /// The requested type cannot possibly work.
+    IncompatibleSize,
+    /// Could not create a new CString.
+    CreateCString { source: std::ffi::NulError },
+    /// Could not create a new CString from bytes with trailing null.
+    CreateCStringWithTrailing { source: std::ffi::FromBytesWithNulError },
+}
+
+impl std::error::Error for Error {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use Error::*;
+        match *self {
+            CreateCString { ref source } => Some(source),
+            CreateCStringWithTrailing { ref source } => Some(source),
+            LoadLibraryW { ref source } => Some(&source.0),
+            GetProcAddress { ref source } => Some(&source.0),
+            FreeLibrary { ref source } => Some(&source.0),
+            _ => None,
+        }
+    }
+}
+
+impl std::fmt::Display for Error {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        use Error::*;
+        match *self {
+            DlOpen { ref desc } => write!(f, "{}", desc.0.to_string_lossy()),
+            DlOpenUnknown => write!(f, "dlopen failed, but system did not report the error"),
+            DlSym { ref desc } => write!(f, "{}", desc.0.to_string_lossy()),
+            DlSymUnknown => write!(f, "dlsym failed, but system did not report the error"),
+            DlClose { ref desc } => write!(f, "{}", desc.0.to_string_lossy()),
+            DlCloseUnknown => write!(f, "dlclose failed, but system did not report the error"),
+            LoadLibraryW { .. } => write!(f, "LoadLibraryW failed"),
+            LoadLibraryWUnknown =>
+                write!(f, "LoadLibraryW failed, but system did not report the error"),
+            GetProcAddress { .. } => write!(f, "GetProcAddress failed"),
+            GetProcAddressUnknown =>
+                write!(f, "GetProcAddress failed, but system did not report the error"),
+            FreeLibrary { .. } => write!(f, "FreeLibrary failed"),
+            FreeLibraryUnknown =>
+                write!(f, "FreeLibrary failed, but system did not report the error"),
+            CreateCString { .. } => write!(f, "could not create a C string from bytes"),
+            CreateCStringWithTrailing { .. } =>
+                write!(f, "could not create a C string from bytes with trailing null"),
+            IncompatibleSize => write!(f, "requested type cannot possibly work"),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn error_send() {
+        fn assert_send<T: Send>() {}
+        assert_send::<super::Error>();
+    }
+
+    #[test]
+    fn error_sync() {
+        fn assert_sync<T: Sync>() {}
+        assert_sync::<super::Error>();
+    }
+
+    #[test]
+    fn error_display() {
+        fn assert_display<T: std::fmt::Display>() {}
+        assert_display::<super::Error>();
+    }
+}
diff --git a/src/lib.rs b/src/lib.rs
new file mode 100644
index 0000000..fad7d63
--- /dev/null
+++ b/src/lib.rs
@@ -0,0 +1,328 @@
+//! A memory-safer wrapper around system dynamic library loading primitives.
+//!
+//! Using this library allows loading [dynamic libraries](struct.Library.html) (also known as
+//! shared libraries) as well as use functions and static variables these libraries contain.
+//!
+//! While the library does expose a cross-platform interface to load a library and find stuff
+//! inside it, little is done to paper over the platform differences, especially where library
+//! loading is involved. The documentation for each function will attempt to document such
+//! differences on the best-effort basis.
+//!
+//! Less safe, platform specific bindings are also available. See the
+//! [`os::platform`](os/index.html) module for details.
+//!
+//! # Usage
+//!
+//! Add a dependency on this library to your `Cargo.toml`:
+//!
+//! ```toml
+//! [dependencies]
+//! libloading = "0.5"
+//! ```
+//!
+//! Then inside your project
+//!
+//! ```no_run
+//! extern crate libloading as lib;
+//!
+//! fn call_dynamic() -> Result<u32, Box<dyn std::error::Error>> {
+//!     let lib = lib::Library::new("/path/to/liblibrary.so")?;
+//!     unsafe {
+//!         let func: lib::Symbol<unsafe extern fn() -> u32> = lib.get(b"my_func")?;
+//!         Ok(func())
+//!     }
+//! }
+//! ```
+//!
+//! The compiler will ensure that the loaded `function` will not outlive the `Library` it comes
+//! from, preventing a common cause of undefined behaviour and memory safety problems.
+use std::ffi::OsStr;
+use std::fmt;
+use std::ops;
+use std::marker;
+
+#[cfg(unix)]
+use self::os::unix as imp;
+#[cfg(windows)]
+use self::os::windows as imp;
+pub use self::error::Error;
+
+pub mod os;
+pub mod changelog;
+mod util;
+mod error;
+
+/// A loaded dynamic library.
+pub struct Library(imp::Library);
+
+impl Library {
+    /// Find and load a dynamic library.
+    ///
+    /// The `filename` argument may be any of:
+    ///
+    /// * A library filename;
+    /// * Absolute path to the library;
+    /// * Relative (to the current working directory) path to the library.
+    ///
+    /// ## Thread-safety
+    ///
+    /// The implementation strives to be as MT-safe as sanely possible, however due to certain
+    /// error-handling related resources not always being safe, this library is not MT-safe either.
+    ///
+    /// * On Windows Vista and earlier error handling falls back to [`SetErrorMode`], which is not
+    ///   MT-safe. MT-scenarios involving this function may cause a traditional data race;
+    /// * On some UNIX targets `dlerror` might not be MT-safe, resulting in garbage error messages
+    ///   in certain MT-scenarios.
+    ///
+    /// [`SetErrorMode`]: https://msdn.microsoft.com/en-us/library/windows/desktop/ms680621(v=vs.85).aspx
+    ///
+    /// Calling this function from multiple threads is not safe if used in conjunction with
+    /// path-less filename and library search path is modified (`SetDllDirectory` function on
+    /// Windows, `{DY,}LD_LIBRARY_PATH` environment variable on UNIX).
+    ///
+    /// ## Platform-specific behaviour
+    ///
+    /// When a plain library filename is supplied, locations where library is searched for is
+    /// platform specific and cannot be adjusted in a portable manner.
+    ///
+    /// ### Windows
+    ///
+    /// If the `filename` specifies a library filename without path and with extension omitted,
+    /// `.dll` extension is implicitly added. This behaviour may be suppressed by appending a
+    /// trailing `.` to the `filename`.
+    ///
+    /// If the library contains thread local variables (MSVC’s `_declspec(thread)`, Rust’s
+    /// `#[thread_local]` attributes), loading the library will fail on versions prior to Windows
+    /// Vista.
+    ///
+    /// ## Tips
+    ///
+    /// Distributing your dynamic libraries under a filename common to all platforms (e.g.
+    /// `awesome.module`) allows to avoid code which has to account for platform’s conventional
+    /// library filenames.
+    ///
+    /// Strive to specify absolute or relative path to your library, unless system-wide libraries
+    /// are being loaded.  Platform-dependent library search locations combined with various quirks
+    /// related to path-less filenames may cause flaky code.
+    ///
+    /// ## Examples
+    ///
+    /// ```no_run
+    /// # use ::libloading::Library;
+    /// // Any of the following are valid.
+    /// let _ = Library::new("/path/to/awesome.module").unwrap();
+    /// let _ = Library::new("../awesome.module").unwrap();
+    /// let _ = Library::new("libsomelib.so.1").unwrap();
+    /// ```
+    pub fn new<P: AsRef<OsStr>>(filename: P) -> Result<Library, Error> {
+        imp::Library::new(filename).map(From::from)
+    }
+
+    /// Get a pointer to function or static variable by symbol name.
+    ///
+    /// The `symbol` may not contain any null bytes, with an exception of last byte. A null
+    /// terminated `symbol` may avoid a string allocation in some cases.
+    ///
+    /// Symbol is interpreted as-is; no mangling is done. This means that symbols like `x::y` are
+    /// most likely invalid.
+    ///
+    /// ## Unsafety
+    ///
+    /// Pointer to a value of arbitrary type is returned. Using a value with wrong type is
+    /// undefined.
+    ///
+    /// ## Platform-specific behaviour
+    ///
+    /// On Linux and Windows, a TLS variable acts just like any regular global variable. OS X uses
+    /// some sort of lazy initialization scheme, which makes loading TLS variables this way
+    /// impossible. Using a TLS variable loaded this way on OS X is undefined behaviour.
+    ///
+    /// On POSIX implementations where the `dlerror` function is not confirmed to be MT-safe (such
+    /// as FreeBSD), this function will unconditionally return an error the underlying `dlsym` call
+    /// returns a null pointer. There are rare situations where `dlsym` returns a genuine null
+    /// pointer without it being an error. If loading a null pointer is something you care about,
+    /// consider using the [`os::unix::Library::get_singlethreaded`] call.
+    ///
+    /// ## Examples
+    ///
+    /// Given a loaded library:
+    ///
+    /// ```no_run
+    /// # use ::libloading::Library;
+    /// let lib = Library::new("/path/to/awesome.module").unwrap();
+    /// ```
+    ///
+    /// Loading and using a function looks like this:
+    ///
+    /// ```no_run
+    /// # use ::libloading::{Library, Symbol};
+    /// # let lib = Library::new("/path/to/awesome.module").unwrap();
+    /// unsafe {
+    ///     let awesome_function: Symbol<unsafe extern fn(f64) -> f64> =
+    ///         lib.get(b"awesome_function\0").unwrap();
+    ///     awesome_function(0.42);
+    /// }
+    /// ```
+    ///
+    /// A static variable may also be loaded and inspected:
+    ///
+    /// ```no_run
+    /// # use ::libloading::{Library, Symbol};
+    /// # let lib = Library::new("/path/to/awesome.module").unwrap();
+    /// unsafe {
+    ///     let awesome_variable: Symbol<*mut f64> = lib.get(b"awesome_variable\0").unwrap();
+    ///     **awesome_variable = 42.0;
+    /// };
+    /// ```
+    pub unsafe fn get<'lib, T>(&'lib self, symbol: &[u8]) -> Result<Symbol<'lib, T>, Error> {
+        self.0.get(symbol).map(|from| Symbol::from_raw(from, self))
+    }
+
+    /// Unload the library.
+    ///
+    /// This method might be a no-op, depending on the flags with which the `Library` was opened,
+    /// what library was opened or other platform specifics.
+    ///
+    /// You only need to call this if you are interested in handling any errors that may arise when
+    /// library is unloaded. Otherwise the implementation of `Drop` for `Library` will close the
+    /// library and ignore the errors were they arise.
+    pub fn close(self) -> Result<(), Error> {
+        self.0.close()
+    }
+}
+
+impl fmt::Debug for Library {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+impl From<imp::Library> for Library {
+    fn from(lib: imp::Library) -> Library {
+        Library(lib)
+    }
+}
+
+impl From<Library> for imp::Library {
+    fn from(lib: Library) -> imp::Library {
+        lib.0
+    }
+}
+
+unsafe impl Send for Library {}
+unsafe impl Sync for Library {}
+
+/// Symbol from a library.
+///
+/// This type is a safeguard against using dynamically loaded symbols after a `Library` is
+/// unloaded. Primary method to create an instance of a `Symbol` is via `Library::get`.
+///
+/// Due to implementation of the `Deref` trait, an instance of `Symbol` may be used as if it was a
+/// function or variable directly, without taking care to “extract” function or variable manually
+/// most of the time.
+///
+/// See [`Library::get`] for details.
+///
+/// [`Library::get`]: ./struct.Library.html#method.get
+pub struct Symbol<'lib, T: 'lib> {
+    inner: imp::Symbol<T>,
+    pd: marker::PhantomData<&'lib T>
+}
+
+impl<'lib, T> Symbol<'lib, T> {
+    /// Extract the wrapped `os::platform::Symbol`.
+    ///
+    /// ## Unsafety
+    /// Using this function relinquishes all the lifetime guarantees. It is up to programmer to
+    /// ensure the resulting `Symbol` is not used past the lifetime of the `Library` this symbol
+    /// was loaded from.
+    ///
+    /// ## Examples
+    ///
+    /// ```no_run
+    /// # use ::libloading::{Library, Symbol};
+    /// let lib = Library::new("/path/to/awesome.module").unwrap();
+    /// unsafe {
+    ///     let symbol: Symbol<*mut u32> = lib.get(b"symbol\0").unwrap();
+    ///     let symbol = symbol.into_raw();
+    /// }
+    /// ```
+    pub unsafe fn into_raw(self) -> imp::Symbol<T> {
+        self.inner
+    }
+
+    /// Wrap the `os::platform::Symbol` into this safe wrapper.
+    ///
+    /// Note that, in order to create association between the symbol and the library this symbol
+    /// came from, this function requires reference to the library provided.
+    ///
+    /// ## Unsafety
+    ///
+    /// It is invalid to provide a reference to any other value other than the library the `sym`
+    /// was loaded from. Doing so invalidates any lifetime guarantees.
+    ///
+    /// ## Examples
+    ///
+    /// ```no_run
+    /// # use ::libloading::{Library, Symbol};
+    /// let lib = Library::new("/path/to/awesome.module").unwrap();
+    /// unsafe {
+    ///     let symbol: Symbol<*mut u32> = lib.get(b"symbol\0").unwrap();
+    ///     let symbol = symbol.into_raw();
+    ///     let symbol = Symbol::from_raw(symbol, &lib);
+    /// }
+    /// ```
+    pub unsafe fn from_raw<L>(sym: imp::Symbol<T>, _: &'lib L) -> Symbol<'lib, T> {
+        Symbol {
+            inner: sym,
+            pd: marker::PhantomData
+        }
+    }
+}
+
+impl<'lib, T> Symbol<'lib, Option<T>> {
+    /// Lift Option out of the symbol.
+    ///
+    /// ## Examples
+    ///
+    /// ```no_run
+    /// # use ::libloading::{Library, Symbol};
+    /// let lib = Library::new("/path/to/awesome.module").unwrap();
+    /// unsafe {
+    ///     let symbol: Symbol<Option<*mut u32>> = lib.get(b"symbol\0").unwrap();
+    ///     let symbol: Symbol<*mut u32> = symbol.lift_option().expect("static is not null");
+    /// }
+    /// ```
+    pub fn lift_option(self) -> Option<Symbol<'lib, T>> {
+        self.inner.lift_option().map(|is| Symbol {
+            inner: is,
+            pd: marker::PhantomData,
+        })
+    }
+}
+
+impl<'lib, T> Clone for Symbol<'lib, T> {
+    fn clone(&self) -> Symbol<'lib, T> {
+        Symbol {
+            inner: self.inner.clone(),
+            pd: marker::PhantomData
+        }
+    }
+}
+
+// FIXME: implement FnOnce for callable stuff instead.
+impl<'lib, T> ops::Deref for Symbol<'lib, T> {
+    type Target = T;
+    fn deref(&self) -> &T {
+        ops::Deref::deref(&self.inner)
+    }
+}
+
+impl<'lib, T> fmt::Debug for Symbol<'lib, T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.inner.fmt(f)
+    }
+}
+
+unsafe impl<'lib, T: Send> Send for Symbol<'lib, T> {}
+unsafe impl<'lib, T: Sync> Sync for Symbol<'lib, T> {}
diff --git a/src/os/mod.rs b/src/os/mod.rs
new file mode 100644
index 0000000..ccbc8e9
--- /dev/null
+++ b/src/os/mod.rs
@@ -0,0 +1,45 @@
+//! Unsafe, platform specific bindings to dynamic library loading facilities.
+//!
+//! These modules expose more extensive, powerful, less principled bindings to the dynamic
+//! library loading facilities. Use of these bindings come at the cost of less (in most cases,
+//! none at all) safety guarantees, which are provided by the top-level bindings.
+//!
+//! # Examples
+//!
+//! Using these modules will likely involve conditional compilation:
+//!
+//! ```ignore
+//! # extern crate libloading;
+//! #[cfg(unix)]
+//! use libloading::os::unix::*;
+//! #[cfg(windows)]
+//! use libloading::os::windows::*;
+//! ```
+
+macro_rules! unix {
+    ($item: item) => {
+        /// UNIX implementation of dynamic library loading.
+        ///
+        /// This module should be expanded with more UNIX-specific functionality in the future.
+        $item
+    }
+}
+
+macro_rules! windows {
+    ($item: item) => {
+        /// Windows implementation of dynamic library loading.
+        ///
+        /// This module should be expanded with more Windows-specific functionality in the future.
+        $item
+    }
+}
+
+#[cfg(unix)]
+unix!(pub mod unix;);
+#[cfg(unix)]
+windows!(pub mod windows {});
+
+#[cfg(windows)]
+windows!(pub mod windows;);
+#[cfg(windows)]
+unix!(pub mod unix {});
diff --git a/src/os/unix/mod.rs b/src/os/unix/mod.rs
new file mode 100644
index 0000000..29d2003
--- /dev/null
+++ b/src/os/unix/mod.rs
@@ -0,0 +1,400 @@
+use util::{ensure_compatible_types, cstr_cow_from_bytes};
+
+use std::ffi::{CStr, OsStr};
+use std::{fmt, marker, mem, ptr};
+use std::os::raw;
+use std::os::unix::ffi::OsStrExt;
+
+// dl* family of functions did not have enough thought put into it.
+//
+// Whole error handling scheme is done via setting and querying some global state, therefore it is
+// not safe to use dynamic library loading in MT-capable environment at all. Only in POSIX 2008+TC1
+// a thread-local state was allowed for `dlerror`, making the dl* family of functions MT-safe.
+//
+// In practice (as of 2020-04-01) most of the widely used targets use a thread-local for error
+// state and have been doing so for a long time. Regardless the comments in this function shall
+// remain as a documentation for the future generations.
+fn with_dlerror<T, F>(wrap: fn(crate::error::DlDescription) -> crate::Error, closure: F)
+-> Result<T, Option<crate::Error>>
+where F: FnOnce() -> Option<T> {
+    // We used to guard all uses of dl* functions with our own mutex. This made them safe to use in
+    // MT programs provided the only way a program used dl* was via this library. However, it also
+    // had a number of downsides or cases where it failed to handle the problems. For instance,
+    // if any other library called `dlerror` internally concurrently with `libloading` things would
+    // still go awry.
+    //
+    // On platforms where `dlerror` is still MT-unsafe, `dlsym` (`Library::get`) can spuriously
+    // succeed and return a null pointer for a symbol when the actual symbol look-up operation
+    // fails. Instances where the actual symbol _could_ be `NULL` are platform specific. For
+    // instance on GNU glibc based-systems (an excerpt from dlsym(3)):
+    //
+    // > The value of a symbol returned by dlsym() will never be NULL if the shared object is the
+    // > result of normal compilation,  since  a  global  symbol is never placed at the NULL
+    // > address. There are nevertheless cases where a lookup using dlsym() may return NULL as the
+    // > value of a symbol. For example, the symbol value may be  the  result of a GNU indirect
+    // > function (IFUNC) resolver function that returns NULL as the resolved value.
+
+    // While we could could call `dlerror` here to clear the previous error value, only the `dlsym`
+    // call depends on it being cleared beforehand and only in some cases too. We will instead
+    // clear the error inside the dlsym binding instead.
+    //
+    // In all the other cases, clearing the error here will only be hiding misuse of these bindings
+    // or a bug in implementation of dl* family of functions.
+    closure().ok_or_else(|| unsafe {
+        // This code will only get executed if the `closure` returns `None`.
+        let error = dlerror();
+        if error.is_null() {
+            // In non-dlsym case this may happen when there’re bugs in our bindings or there’s
+            // non-libloading user of libdl; possibly in another thread.
+            None
+        } else {
+            // You can’t even rely on error string being static here; call to subsequent dlerror
+            // may invalidate or overwrite the error message. Why couldn’t they simply give up the
+            // ownership over the message?
+            // TODO: should do locale-aware conversion here. OTOH Rust doesn’t seem to work well in
+            // any system that uses non-utf8 locale, so I doubt there’s a problem here.
+            let message = CStr::from_ptr(error).into();
+            Some(wrap(crate::error::DlDescription(message)))
+            // Since we do a copy of the error string above, maybe we should call dlerror again to
+            // let libdl know it may free its copy of the string now?
+        }
+    })
+}
+
+/// A platform-specific equivalent of the cross-platform `Library`.
+pub struct Library {
+    handle: *mut raw::c_void
+}
+
+unsafe impl Send for Library {}
+
+// That being said... this section in the volume 2 of POSIX.1-2008 states:
+//
+// > All functions defined by this volume of POSIX.1-2008 shall be thread-safe, except that the
+// > following functions need not be thread-safe.
+//
+// With notable absence of any dl* function other than dlerror in the list. By “this volume”
+// I suppose they refer precisely to the “volume 2”. dl* family of functions are specified
+// by this same volume, so the conclusion is indeed that dl* functions are required by POSIX
+// to be thread-safe. Great!
+//
+// See for more details:
+//
+//  * https://github.com/nagisa/rust_libloading/pull/17
+//  * http://pubs.opengroup.org/onlinepubs/9699919799/functions/V2_chap02.html#tag_15_09_01
+unsafe impl Sync for Library {}
+
+impl Library {
+    /// Find and load a shared library (module).
+    ///
+    /// Locations where library is searched for is platform specific and can’t be adjusted
+    /// portably.
+    ///
+    /// Corresponds to `dlopen(filename, RTLD_NOW)`.
+    #[inline]
+    pub fn new<P: AsRef<OsStr>>(filename: P) -> Result<Library, crate::Error> {
+        Library::open(Some(filename), RTLD_NOW)
+    }
+
+    /// Load the dynamic libraries linked into main program.
+    ///
+    /// This allows retrieving symbols from any **dynamic** library linked into the program,
+    /// without specifying the exact library.
+    ///
+    /// Corresponds to `dlopen(NULL, RTLD_NOW)`.
+    #[inline]
+    pub fn this() -> Library {
+        Library::open(None::<&OsStr>, RTLD_NOW).expect("this should never fail")
+    }
+
+    /// Find and load a shared library (module).
+    ///
+    /// Locations where library is searched for is platform specific and can’t be adjusted
+    /// portably.
+    ///
+    /// If the `filename` is None, null pointer is passed to `dlopen`.
+    ///
+    /// Corresponds to `dlopen(filename, flags)`.
+    pub fn open<P>(filename: Option<P>, flags: raw::c_int) -> Result<Library, crate::Error>
+    where P: AsRef<OsStr> {
+        let filename = match filename {
+            None => None,
+            Some(ref f) => Some(cstr_cow_from_bytes(f.as_ref().as_bytes())?),
+        };
+        with_dlerror(|desc| crate::Error::DlOpen { desc }, move || {
+            let result = unsafe {
+                let r = dlopen(match filename {
+                    None => ptr::null(),
+                    Some(ref f) => f.as_ptr()
+                }, flags);
+                // ensure filename lives until dlopen completes
+                drop(filename);
+                r
+            };
+            if result.is_null() {
+                None
+            } else {
+                Some(Library {
+                    handle: result
+                })
+            }
+        }).map_err(|e| e.unwrap_or(crate::Error::DlOpenUnknown))
+    }
+
+    unsafe fn get_impl<T, F>(&self, symbol: &[u8], on_null: F) -> Result<Symbol<T>, crate::Error>
+    where F: FnOnce() -> Result<Symbol<T>, crate::Error>
+    {
+        ensure_compatible_types::<T, *mut raw::c_void>()?;
+        let symbol = cstr_cow_from_bytes(symbol)?;
+        // `dlsym` may return nullptr in two cases: when a symbol genuinely points to a null
+        // pointer or the symbol cannot be found. In order to detect this case a double dlerror
+        // pattern must be used, which is, sadly, a little bit racy.
+        //
+        // We try to leave as little space as possible for this to occur, but we can’t exactly
+        // fully prevent it.
+        match with_dlerror(|desc| crate::Error::DlSym { desc }, || {
+            dlerror();
+            let symbol = dlsym(self.handle, symbol.as_ptr());
+            if symbol.is_null() {
+                None
+            } else {
+                Some(Symbol {
+                    pointer: symbol,
+                    pd: marker::PhantomData
+                })
+            }
+        }) {
+            Err(None) => on_null(),
+            Err(Some(e)) => Err(e),
+            Ok(x) => Ok(x)
+        }
+
+    }
+
+    /// Get a pointer to function or static variable by symbol name.
+    ///
+    /// The `symbol` may not contain any null bytes, with an exception of last byte. A null
+    /// terminated `symbol` may avoid a string allocation in some cases.
+    ///
+    /// Symbol is interpreted as-is; no mangling is done. This means that symbols like `x::y` are
+    /// most likely invalid.
+    ///
+    /// ## Unsafety
+    ///
+    /// This function does not validate the type `T`. It is up to the user of this function to
+    /// ensure that the loaded symbol is in fact a `T`. Using a value with a wrong type has no
+    /// definied behaviour.
+    ///
+    ///
+    ///
+    /// ## Platform-specific behaviour
+    ///
+    /// OS X uses some sort of lazy initialization scheme, which makes loading TLS variables
+    /// impossible. Using a TLS variable loaded this way on OS X is undefined behaviour.
+    ///
+    /// On POSIX implementations where the `dlerror` function is not confirmed to be MT-safe (such
+    /// as FreeBSD), this function will unconditionally return an error the underlying `dlsym` call
+    /// returns a null pointer. There are rare situations where `dlsym` returns a genuine null
+    /// pointer without it being an error. If loading a null pointer is something you care about,
+    /// consider using the [`Library::get_singlethreaded`] call.
+    #[inline(always)]
+    pub unsafe fn get<T>(&self, symbol: &[u8]) -> Result<Symbol<T>, crate::Error> {
+        #[cfg(mtsafe_dlerror)]
+        { return self.get_singlethreaded(symbol); }
+        #[cfg(not(mtsafe_dlerror))]
+        {
+            return self.get_impl(symbol, || Err(crate::Error::DlSymUnknown));
+        }
+    }
+
+    /// Get a pointer to function or static variable by symbol name.
+    ///
+    /// The `symbol` may not contain any null bytes, with an exception of last byte. A null
+    /// terminated `symbol` may avoid a string allocation in some cases.
+    ///
+    /// Symbol is interpreted as-is; no mangling is done. This means that symbols like `x::y` are
+    /// most likely invalid.
+    ///
+    /// ## Unsafety
+    ///
+    /// This function does not validate the type `T`. It is up to the user of this function to
+    /// ensure that the loaded symbol is in fact a `T`. Using a value with a wrong type has no
+    /// definied behaviour.
+    ///
+    /// It is up to the user of this library to ensure that no other calls to an MT-unsafe
+    /// implementation of `dlerror` occur while this function is executing. Failing that the
+    /// results of this function are not defined.
+    ///
+    /// ## Platform-specific behaviour
+    ///
+    /// OS X uses some sort of lazy initialization scheme, which makes loading TLS variables
+    /// impossible. Using a TLS variable loaded this way on OS X is undefined behaviour.
+    #[inline(always)]
+    pub unsafe fn get_singlethreaded<T>(&self, symbol: &[u8]) -> Result<Symbol<T>, crate::Error> {
+        self.get_impl(symbol, || Ok(Symbol {
+            pointer: ptr::null_mut(),
+            pd: marker::PhantomData
+        }))
+    }
+
+    /// Convert the `Library` to a raw handle.
+    ///
+    /// The handle returned by this function shall be usable with APIs which accept handles
+    /// as returned by `dlopen`.
+    pub fn into_raw(self) -> *mut raw::c_void {
+        let handle = self.handle;
+        mem::forget(self);
+        handle
+    }
+
+    /// Convert a raw handle returned by `dlopen`-family of calls to a `Library`.
+    ///
+    /// ## Unsafety
+    ///
+    /// The pointer shall be a result of a successful call of the `dlopen`-family of functions or a
+    /// pointer previously returned by `Library::into_raw` call. It must be valid to call `dlclose`
+    /// with this pointer as an argument.
+    pub unsafe fn from_raw(handle: *mut raw::c_void) -> Library {
+        Library {
+            handle: handle
+        }
+    }
+
+    /// Unload the library.
+    ///
+    /// This method might be a no-op, depending on the flags with which the `Library` was opened,
+    /// what library was opened or other platform specifics.
+    ///
+    /// You only need to call this if you are interested in handling any errors that may arise when
+    /// library is unloaded. Otherwise the implementation of `Drop` for `Library` will close the
+    /// library and ignore the errors were they arise.
+    pub fn close(self) -> Result<(), crate::Error> {
+        let result = with_dlerror(|desc| crate::Error::DlClose { desc }, || {
+            if unsafe { dlclose(self.handle) } == 0 {
+                Some(())
+            } else {
+                None
+            }
+        }).map_err(|e| e.unwrap_or(crate::Error::DlCloseUnknown));
+        std::mem::forget(self);
+        result
+    }
+}
+
+impl Drop for Library {
+    fn drop(&mut self) {
+        unsafe {
+            dlclose(self.handle);
+        }
+    }
+}
+
+impl fmt::Debug for Library {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str(&format!("Library@{:p}", self.handle))
+    }
+}
+
+/// Symbol from a library.
+///
+/// A major difference compared to the cross-platform `Symbol` is that this does not ensure the
+/// `Symbol` does not outlive `Library` it comes from.
+pub struct Symbol<T> {
+    pointer: *mut raw::c_void,
+    pd: marker::PhantomData<T>
+}
+
+impl<T> Symbol<T> {
+    /// Convert the loaded Symbol into a raw pointer.
+    pub fn into_raw(self) -> *mut raw::c_void {
+        let pointer = self.pointer;
+        mem::forget(self);
+        pointer
+    }
+}
+
+impl<T> Symbol<Option<T>> {
+    /// Lift Option out of the symbol.
+    pub fn lift_option(self) -> Option<Symbol<T>> {
+        if self.pointer.is_null() {
+            None
+        } else {
+            Some(Symbol {
+                pointer: self.pointer,
+                pd: marker::PhantomData,
+            })
+        }
+    }
+}
+
+unsafe impl<T: Send> Send for Symbol<T> {}
+unsafe impl<T: Sync> Sync for Symbol<T> {}
+
+impl<T> Clone for Symbol<T> {
+    fn clone(&self) -> Symbol<T> {
+        Symbol { ..*self }
+    }
+}
+
+impl<T> ::std::ops::Deref for Symbol<T> {
+    type Target = T;
+    fn deref(&self) -> &T {
+        unsafe {
+            // Additional reference level for a dereference on `deref` return value.
+            mem::transmute(&self.pointer)
+        }
+    }
+}
+
+impl<T> fmt::Debug for Symbol<T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        unsafe {
+            let mut info = mem::MaybeUninit::<DlInfo>::uninit();
+            if dladdr(self.pointer, info.as_mut_ptr()) != 0 {
+                let info = info.assume_init();
+                if info.dli_sname.is_null() {
+                    f.write_str(&format!("Symbol@{:p} from {:?}",
+                                         self.pointer,
+                                         CStr::from_ptr(info.dli_fname)))
+                } else {
+                    f.write_str(&format!("Symbol {:?}@{:p} from {:?}",
+                                         CStr::from_ptr(info.dli_sname), self.pointer,
+                                         CStr::from_ptr(info.dli_fname)))
+                }
+            } else {
+                f.write_str(&format!("Symbol@{:p}", self.pointer))
+            }
+        }
+    }
+}
+
+// Platform specific things
+
+extern {
+    fn dlopen(filename: *const raw::c_char, flags: raw::c_int) -> *mut raw::c_void;
+    fn dlclose(handle: *mut raw::c_void) -> raw::c_int;
+    fn dlsym(handle: *mut raw::c_void, symbol: *const raw::c_char) -> *mut raw::c_void;
+    fn dlerror() -> *mut raw::c_char;
+    fn dladdr(addr: *mut raw::c_void, info: *mut DlInfo) -> raw::c_int;
+}
+
+#[cfg(not(target_os="android"))]
+const RTLD_NOW: raw::c_int = 2;
+#[cfg(target_os="android")]
+const RTLD_NOW: raw::c_int = 0;
+
+#[repr(C)]
+struct DlInfo {
+  dli_fname: *const raw::c_char,
+  dli_fbase: *mut raw::c_void,
+  dli_sname: *const raw::c_char,
+  dli_saddr: *mut raw::c_void
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn this() {
+        super::Library::this();
+    }
+}
diff --git a/src/os/windows/mod.rs b/src/os/windows/mod.rs
new file mode 100644
index 0000000..3620b3e
--- /dev/null
+++ b/src/os/windows/mod.rs
@@ -0,0 +1,332 @@
+extern crate winapi;
+use self::winapi::shared::minwindef::{WORD, DWORD, HMODULE, FARPROC};
+use self::winapi::shared::ntdef::WCHAR;
+use self::winapi::shared::winerror;
+use self::winapi::um::{errhandlingapi, libloaderapi};
+
+use util::{ensure_compatible_types, cstr_cow_from_bytes};
+
+use std::ffi::{OsStr, OsString};
+use std::{fmt, io, marker, mem, ptr};
+use std::os::windows::ffi::{OsStrExt, OsStringExt};
+use std::sync::atomic::{AtomicBool, Ordering};
+
+/// A platform-specific equivalent of the cross-platform `Library`.
+pub struct Library(HMODULE);
+
+unsafe impl Send for Library {}
+// Now, this is sort-of-tricky. MSDN documentation does not really make any claims as to safety of
+// the Win32 APIs. Sadly, whomever I asked, even current and former Microsoft employees, couldn’t
+// say for sure, whether the Win32 APIs used to implement `Library` are thread-safe or not.
+//
+// My investigation ended up with a question about thread-safety properties of the API involved
+// being sent to an internal (to MS) general question mailing-list. The conclusion of the mail is
+// as such:
+//
+// * Nobody inside MS (at least out of all the people who have seen the question) knows for
+//   sure either;
+// * However, the general consensus between MS developers is that one can rely on the API being
+//   thread-safe. In case it is not thread-safe it should be considered a bug on the Windows
+//   part. (NB: bugs filled at https://connect.microsoft.com/ against Windows Server)
+unsafe impl Sync for Library {}
+
+impl Library {
+    /// Find and load a shared library (module).
+    ///
+    /// Corresponds to `LoadLibraryW(filename, reserved: NULL, flags: 0)` which is equivalent to `LoadLibraryW(filename)`
+    #[inline]
+    pub fn new<P: AsRef<OsStr>>(filename: P) -> Result<Library, crate::Error> {
+        Library::load_with_flags(filename, 0)
+    }
+
+    /// Find and load a shared library (module).
+    ///
+    /// Locations where library is searched for is platform specific and can’t be adjusted
+    /// portably.
+    ///
+    /// Corresponds to `LoadLibraryW(filename, reserved: NULL, flags)`.
+    pub fn load_with_flags<P: AsRef<OsStr>>(filename: P, flags: DWORD) -> Result<Library, crate::Error> {
+        let wide_filename: Vec<u16> = filename.as_ref().encode_wide().chain(Some(0)).collect();
+        let _guard = ErrorModeGuard::new();
+
+        let ret = with_get_last_error(|source| crate::Error::LoadLibraryW { source }, || {
+            // Make sure no winapi calls as a result of drop happen inside this closure, because
+            // otherwise that might change the return value of the GetLastError.
+            let handle = unsafe { libloaderapi::LoadLibraryExW(wide_filename.as_ptr(), std::ptr::null_mut(), flags) };
+            if handle.is_null()  {
+                None
+            } else {
+                Some(Library(handle))
+            }
+        }).map_err(|e| e.unwrap_or(crate::Error::LoadLibraryWUnknown));
+        drop(wide_filename); // Drop wide_filename here to ensure it doesn’t get moved and dropped
+                             // inside the closure by mistake. See comment inside the closure.
+        ret
+    }
+
+    /// Get a pointer to function or static variable by symbol name.
+    ///
+    /// The `symbol` may not contain any null bytes, with an exception of last byte. A null
+    /// terminated `symbol` may avoid a string allocation in some cases.
+    ///
+    /// Symbol is interpreted as-is; no mangling is done. This means that symbols like `x::y` are
+    /// most likely invalid.
+    ///
+    /// ## Unsafety
+    ///
+    /// This function does not validate the type `T`. It is up to the user of this function to
+    /// ensure that the loaded symbol is in fact a `T`. Using a value with a wrong type has no
+    /// definied behaviour.
+    pub unsafe fn get<T>(&self, symbol: &[u8]) -> Result<Symbol<T>, crate::Error> {
+        ensure_compatible_types::<T, FARPROC>()?;
+        let symbol = cstr_cow_from_bytes(symbol)?;
+        with_get_last_error(|source| crate::Error::GetProcAddress { source }, || {
+            let symbol = libloaderapi::GetProcAddress(self.0, symbol.as_ptr());
+            if symbol.is_null() {
+                None
+            } else {
+                Some(Symbol {
+                    pointer: symbol,
+                    pd: marker::PhantomData
+                })
+            }
+        }).map_err(|e| e.unwrap_or(crate::Error::GetProcAddressUnknown))
+    }
+
+    /// Get a pointer to function or static variable by ordinal number.
+    ///
+    /// ## Unsafety
+    ///
+    /// Pointer to a value of arbitrary type is returned. Using a value with wrong type is
+    /// undefined.
+    pub unsafe fn get_ordinal<T>(&self, ordinal: WORD) -> Result<Symbol<T>, crate::Error> {
+        ensure_compatible_types::<T, FARPROC>()?;
+        with_get_last_error(|source| crate::Error::GetProcAddress { source }, || {
+            let ordinal = ordinal as usize as *mut _;
+            let symbol = libloaderapi::GetProcAddress(self.0, ordinal);
+            if symbol.is_null() {
+                None
+            } else {
+                Some(Symbol {
+                    pointer: symbol,
+                    pd: marker::PhantomData
+                })
+            }
+        }).map_err(|e| e.unwrap_or(crate::Error::GetProcAddressUnknown))
+    }
+
+    /// Convert the `Library` to a raw handle.
+    pub fn into_raw(self) -> HMODULE {
+        let handle = self.0;
+        mem::forget(self);
+        handle
+    }
+
+    /// Convert a raw handle to a `Library`.
+    ///
+    /// ## Unsafety
+    ///
+    /// The handle shall be a result of a successful call of `LoadLibraryW` or a
+    /// handle previously returned by the `Library::into_raw` call.
+    pub unsafe fn from_raw(handle: HMODULE) -> Library {
+        Library(handle)
+    }
+
+    /// Unload the library.
+    pub fn close(self) -> Result<(), crate::Error> {
+        with_get_last_error(|source| crate::Error::FreeLibrary { source }, || {
+            if unsafe { libloaderapi::FreeLibrary(self.0) == 0 } {
+                None
+            } else {
+                Some(())
+            }
+        }).map_err(|e| e.unwrap_or(crate::Error::FreeLibraryUnknown))
+    }
+}
+
+impl Drop for Library {
+    fn drop(&mut self) {
+        unsafe { libloaderapi::FreeLibrary(self.0); }
+    }
+}
+
+impl fmt::Debug for Library {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        unsafe {
+            // FIXME: use Maybeuninit::uninit_array when stable
+            let mut buf =
+                mem::MaybeUninit::<[mem::MaybeUninit::<WCHAR>; 1024]>::uninit().assume_init();
+            let len = libloaderapi::GetModuleFileNameW(self.0,
+                (&mut buf[..]).as_mut_ptr().cast(), 1024) as usize;
+            if len == 0 {
+                f.write_str(&format!("Library@{:p}", self.0))
+            } else {
+                let string: OsString = OsString::from_wide(
+                    // FIXME: use Maybeuninit::slice_get_ref when stable
+                    &*(&buf[..len] as *const [_] as *const [WCHAR])
+                );
+                f.write_str(&format!("Library@{:p} from {:?}", self.0, string))
+            }
+        }
+    }
+}
+
+/// Symbol from a library.
+///
+/// A major difference compared to the cross-platform `Symbol` is that this does not ensure the
+/// `Symbol` does not outlive `Library` it comes from.
+pub struct Symbol<T> {
+    pointer: FARPROC,
+    pd: marker::PhantomData<T>
+}
+
+impl<T> Symbol<T> {
+    /// Convert the loaded Symbol into a handle.
+    pub fn into_raw(self) -> FARPROC {
+        let pointer = self.pointer;
+        mem::forget(self);
+        pointer
+    }
+}
+
+impl<T> Symbol<Option<T>> {
+    /// Lift Option out of the symbol.
+    pub fn lift_option(self) -> Option<Symbol<T>> {
+        if self.pointer.is_null() {
+            None
+        } else {
+            Some(Symbol {
+                pointer: self.pointer,
+                pd: marker::PhantomData,
+            })
+        }
+    }
+}
+
+unsafe impl<T: Send> Send for Symbol<T> {}
+unsafe impl<T: Sync> Sync for Symbol<T> {}
+
+impl<T> Clone for Symbol<T> {
+    fn clone(&self) -> Symbol<T> {
+        Symbol { ..*self }
+    }
+}
+
+impl<T> ::std::ops::Deref for Symbol<T> {
+    type Target = T;
+    fn deref(&self) -> &T {
+        unsafe {
+            // Additional reference level for a dereference on `deref` return value.
+            mem::transmute(&self.pointer)
+        }
+    }
+}
+
+impl<T> fmt::Debug for Symbol<T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str(&format!("Symbol@{:p}", self.pointer))
+    }
+}
+
+
+static USE_ERRORMODE: AtomicBool = AtomicBool::new(false);
+struct ErrorModeGuard(DWORD);
+
+impl ErrorModeGuard {
+    fn new() -> Option<ErrorModeGuard> {
+        const SEM_FAILCE: DWORD = 1;
+        unsafe {
+            if !USE_ERRORMODE.load(Ordering::Acquire) {
+                let mut previous_mode = 0;
+                let success = errhandlingapi::SetThreadErrorMode(SEM_FAILCE, &mut previous_mode) != 0;
+                if !success && errhandlingapi::GetLastError() == winerror::ERROR_CALL_NOT_IMPLEMENTED {
+                    USE_ERRORMODE.store(true, Ordering::Release);
+                } else if !success {
+                    // SetThreadErrorMode failed with some other error? How in the world is it
+                    // possible for what is essentially a simple variable swap to fail?
+                    // For now we just ignore the error -- the worst that can happen here is
+                    // the previous mode staying on and user seeing a dialog error on older Windows
+                    // machines.
+                    return None;
+                } else if previous_mode == SEM_FAILCE {
+                    return None;
+                } else {
+                    return Some(ErrorModeGuard(previous_mode));
+                }
+            }
+            match errhandlingapi::SetErrorMode(SEM_FAILCE) {
+                SEM_FAILCE => {
+                    // This is important to reduce racy-ness when this library is used on multiple
+                    // threads. In particular this helps with following race condition:
+                    //
+                    // T1: SetErrorMode(SEM_FAILCE)
+                    // T2: SetErrorMode(SEM_FAILCE)
+                    // T1: SetErrorMode(old_mode) # not SEM_FAILCE
+                    // T2: SetErrorMode(SEM_FAILCE) # restores to SEM_FAILCE on drop
+                    //
+                    // This is still somewhat racy in a sense that T1 might restore the error
+                    // mode before T2 finishes loading the library, but that is less of a
+                    // concern – it will only end up in end user seeing a dialog.
+                    //
+                    // Also, SetErrorMode itself is probably not an atomic operation.
+                    None
+                }
+                a => Some(ErrorModeGuard(a))
+            }
+        }
+    }
+}
+
+impl Drop for ErrorModeGuard {
+    fn drop(&mut self) {
+        unsafe {
+            if !USE_ERRORMODE.load(Ordering::Relaxed) {
+                errhandlingapi::SetThreadErrorMode(self.0, ptr::null_mut());
+            } else {
+                errhandlingapi::SetErrorMode(self.0);
+            }
+        }
+    }
+}
+
+fn with_get_last_error<T, F>(wrap: fn(crate::error::WindowsError) -> crate::Error, closure: F)
+-> Result<T, Option<crate::Error>>
+where F: FnOnce() -> Option<T> {
+    closure().ok_or_else(|| {
+        let error = unsafe { errhandlingapi::GetLastError() };
+        if error == 0 {
+            None
+        } else {
+            Some(wrap(crate::error::WindowsError(io::Error::from_raw_os_error(error as i32))))
+        }
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn works_getlasterror() {
+        let lib = Library::new("kernel32.dll").unwrap();
+        let gle: Symbol<unsafe extern "system" fn() -> DWORD> = unsafe {
+            lib.get(b"GetLastError").unwrap()
+        };
+        unsafe {
+            errhandlingapi::SetLastError(42);
+            assert_eq!(errhandlingapi::GetLastError(), gle())
+        }
+    }
+
+    #[test]
+    fn works_getlasterror0() {
+        let lib = Library::new("kernel32.dll").unwrap();
+        let gle: Symbol<unsafe extern "system" fn() -> DWORD> = unsafe {
+            lib.get(b"GetLastError\0").unwrap()
+        };
+        unsafe {
+            errhandlingapi::SetLastError(42);
+            assert_eq!(errhandlingapi::GetLastError(), gle())
+        }
+    }
+}
diff --git a/src/test_helpers.rs b/src/test_helpers.rs
new file mode 100644
index 0000000..32f7023
--- /dev/null
+++ b/src/test_helpers.rs
@@ -0,0 +1,49 @@
+//! This is a separate file containing helpers for tests of this library. It is built into a
+//! dynamic library by the build.rs script.
+#![crate_type="dylib"] // FIXME: should become a cdylib in due time
+#![cfg_attr(test_nightly, feature(thread_local))]
+
+#[no_mangle]
+pub static mut TEST_STATIC_U32: u32 = 0;
+
+#[no_mangle]
+pub static mut TEST_STATIC_PTR: *mut () = 0 as *mut _;
+
+#[cfg(test_nightly)]
+#[thread_local]
+#[no_mangle]
+pub static mut TEST_THREAD_LOCAL: u32 = 0;
+
+#[no_mangle]
+pub extern "C" fn test_identity_u32(x: u32) -> u32 {
+    x
+}
+
+#[repr(C)]
+pub struct S {
+    a: u64,
+    b: u32,
+    c: u16,
+    d: u8
+}
+
+#[no_mangle]
+pub extern "C" fn test_identity_struct(x: S) -> S {
+    x
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn test_get_static_u32() -> u32 {
+    TEST_STATIC_U32
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn test_check_static_ptr() -> bool {
+    TEST_STATIC_PTR == (&mut TEST_STATIC_PTR as *mut *mut _ as *mut _)
+}
+
+#[cfg(test_nightly)]
+#[no_mangle]
+pub unsafe extern "C" fn test_get_thread_local() -> u32 {
+    TEST_THREAD_LOCAL
+}
diff --git a/src/util.rs b/src/util.rs
new file mode 100644
index 0000000..e5108c2
--- /dev/null
+++ b/src/util.rs
@@ -0,0 +1,31 @@
+use std::ffi::{CStr, CString};
+use std::borrow::Cow;
+use std::os::raw;
+
+use crate::Error;
+
+/// Checks for last byte and avoids allocating if it is zero.
+///
+/// Non-last null bytes still result in an error.
+pub(crate) fn cstr_cow_from_bytes<'a>(slice: &'a [u8]) -> Result<Cow<'a, CStr>, Error> {
+    static ZERO: raw::c_char = 0;
+    Ok(match slice.last() {
+        // Slice out of 0 elements
+        None => unsafe { Cow::Borrowed(CStr::from_ptr(&ZERO)) },
+        // Slice with trailing 0
+        Some(&0) => Cow::Borrowed(CStr::from_bytes_with_nul(slice)
+            .map_err(|source| Error::CreateCStringWithTrailing { source })?),
+        // Slice with no trailing 0
+        Some(_) => Cow::Owned(CString::new(slice)
+            .map_err(|source| Error::CreateCString { source })?),
+    })
+}
+
+#[inline]
+pub(crate) fn ensure_compatible_types<T, E>() -> Result<(), Error> {
+    if ::std::mem::size_of::<T>() != ::std::mem::size_of::<E>() {
+        Err(Error::IncompatibleSize)
+    } else {
+        Ok(())
+    }
+}
diff --git a/tests/functions.rs b/tests/functions.rs
new file mode 100644
index 0000000..dece58c
--- /dev/null
+++ b/tests/functions.rs
@@ -0,0 +1,155 @@
+extern crate libloading;
+use libloading::{Symbol, Library};
+
+const LIBPATH: &'static str = concat!(env!("OUT_DIR"), "/libtest_helpers.dll");
+
+fn make_helpers() {
+    static ONCE: ::std::sync::Once = ::std::sync::Once::new();
+    ONCE.call_once(|| {
+        let mut outpath = String::from(if let Some(od) = option_env!("OUT_DIR") { od } else { return });
+        let rustc = option_env!("RUSTC").unwrap_or_else(|| { "rustc".into() });
+        outpath.push_str(&"/libtest_helpers.dll"); // extension for windows required, POSIX does not care.
+        let _ = ::std::process::Command::new(rustc)
+            .arg("src/test_helpers.rs")
+            .arg("-o")
+            .arg(outpath)
+            .arg("-O")
+            .output()
+            .expect("could not compile the test helpers!");
+    });
+}
+
+#[test]
+fn test_id_u32() {
+    make_helpers();
+    let lib = Library::new(LIBPATH).unwrap();
+    unsafe {
+        let f: Symbol<unsafe extern fn(u32) -> u32> = lib.get(b"test_identity_u32\0").unwrap();
+        assert_eq!(42, f(42));
+    }
+}
+
+#[repr(C)]
+#[derive(Clone,Copy,PartialEq,Debug)]
+struct S {
+    a: u64,
+    b: u32,
+    c: u16,
+    d: u8
+}
+
+#[test]
+fn test_id_struct() {
+    make_helpers();
+    let lib = Library::new(LIBPATH).unwrap();
+    unsafe {
+        let f: Symbol<unsafe extern fn(S) -> S> = lib.get(b"test_identity_struct\0").unwrap();
+        assert_eq!(S { a: 1, b: 2, c: 3, d: 4 }, f(S { a: 1, b: 2, c: 3, d: 4 }));
+    }
+}
+
+#[test]
+fn test_0_no_0() {
+    make_helpers();
+    let lib = Library::new(LIBPATH).unwrap();
+    unsafe {
+        let f: Symbol<unsafe extern fn(S) -> S> = lib.get(b"test_identity_struct\0").unwrap();
+        let f2: Symbol<unsafe extern fn(S) -> S> = lib.get(b"test_identity_struct").unwrap();
+        assert_eq!(*f, *f2);
+    }
+}
+
+#[test]
+fn wrong_name_fails() {
+    Library::new(concat!(env!("OUT_DIR"), "/libtest_help")).err().unwrap();
+}
+
+#[test]
+fn missing_symbol_fails() {
+    make_helpers();
+    let lib = Library::new(LIBPATH).unwrap();
+    unsafe {
+        lib.get::<*mut ()>(b"test_does_not_exist").err().unwrap();
+        lib.get::<*mut ()>(b"test_does_not_exist\0").err().unwrap();
+    }
+}
+
+#[test]
+fn interior_null_fails() {
+    make_helpers();
+    let lib = Library::new(LIBPATH).unwrap();
+    unsafe {
+        lib.get::<*mut ()>(b"test_does\0_not_exist").err().unwrap();
+        lib.get::<*mut ()>(b"test\0_does_not_exist\0").err().unwrap();
+    }
+}
+
+#[test]
+fn test_incompatible_type() {
+    make_helpers();
+    let lib = Library::new(LIBPATH).unwrap();
+    unsafe {
+        assert!(match lib.get::<()>(b"test_identity_u32\0") {
+           Err(libloading::Error::IncompatibleSize) => true,
+           _ => false,
+        })
+    }
+}
+
+#[test]
+fn test_incompatible_type_named_fn() {
+    make_helpers();
+    unsafe fn get<'a, T>(l: &'a Library, _: T) -> Result<Symbol<'a, T>, libloading::Error> {
+        l.get::<T>(b"test_identity_u32\0")
+    }
+    let lib = Library::new(LIBPATH).unwrap();
+    unsafe {
+        assert!(match get(&lib, test_incompatible_type_named_fn) {
+           Err(libloading::Error::IncompatibleSize) => true,
+           _ => false,
+        })
+    }
+}
+
+#[test]
+fn test_static_u32() {
+    make_helpers();
+    let lib = Library::new(LIBPATH).unwrap();
+    unsafe {
+        let var: Symbol<*mut u32> = lib.get(b"TEST_STATIC_U32\0").unwrap();
+        **var = 42;
+        let help: Symbol<unsafe extern fn() -> u32> = lib.get(b"test_get_static_u32\0").unwrap();
+        assert_eq!(42, help());
+    }
+}
+
+#[test]
+fn test_static_ptr() {
+    make_helpers();
+    let lib = Library::new(LIBPATH).unwrap();
+    unsafe {
+        let var: Symbol<*mut *mut ()> = lib.get(b"TEST_STATIC_PTR\0").unwrap();
+        **var = *var as *mut _;
+        let works: Symbol<unsafe extern fn() -> bool> =
+            lib.get(b"test_check_static_ptr\0").unwrap();
+        assert!(works());
+    }
+}
+
+#[cfg(any(windows, target_os="linux"))]
+#[cfg(test_nightly)]
+#[test]
+fn test_tls_static() {
+    make_helpers();
+    let lib = Library::new(LIBPATH).unwrap();
+    unsafe {
+        let var: Symbol<*mut u32> = lib.get(b"TEST_THREAD_LOCAL\0").unwrap();
+        **var = 84;
+        let help: Symbol<unsafe extern fn() -> u32> = lib.get(b"test_get_thread_local\0").unwrap();
+        assert_eq!(84, help());
+    }
+    ::std::thread::spawn(move || unsafe {
+        let help: Symbol<unsafe extern fn() -> u32> = lib.get(b"test_get_thread_local\0").unwrap();
+        assert_eq!(0, help());
+    }).join().unwrap();
+}
diff --git a/tests/markers.rs b/tests/markers.rs
new file mode 100644
index 0000000..01da108
--- /dev/null
+++ b/tests/markers.rs
@@ -0,0 +1,79 @@
+extern crate libloading;
+
+#[cfg(test)]
+fn assert_send<T: Send>() {}
+#[cfg(test)]
+fn assert_sync<T: Sync>() {}
+
+#[test]
+fn check_library_send() {
+    assert_send::<libloading::Library>();
+}
+
+#[cfg(unix)]
+#[test]
+fn check_unix_library_send() {
+    assert_send::<libloading::os::unix::Library>();
+}
+
+#[cfg(windows)]
+#[test]
+fn check_windows_library_send() {
+    assert_send::<libloading::os::windows::Library>();
+}
+
+#[test]
+fn check_library_sync() {
+    assert_sync::<libloading::Library>();
+}
+
+#[cfg(unix)]
+#[test]
+fn check_unix_library_sync() {
+    assert_sync::<libloading::os::unix::Library>();
+}
+
+#[cfg(windows)]
+#[test]
+fn check_windows_library_sync() {
+    assert_sync::<libloading::os::windows::Library>();
+}
+
+#[test]
+fn check_symbol_send() {
+    assert_send::<libloading::Symbol<fn() -> ()>>();
+    // assert_not_send::<libloading::Symbol<*const ()>>();
+}
+
+#[cfg(unix)]
+#[test]
+fn check_unix_symbol_send() {
+    assert_send::<libloading::os::unix::Symbol<fn() -> ()>>();
+    // assert_not_send::<libloading::os::unix::Symbol<*const ()>>();
+}
+
+#[cfg(windows)]
+#[test]
+fn check_windows_symbol_send() {
+    assert_send::<libloading::os::windows::Symbol<fn() -> ()>>();
+}
+
+#[test]
+fn check_symbol_sync() {
+    assert_sync::<libloading::Symbol<fn() -> ()>>();
+    // assert_not_sync::<libloading::Symbol<*const ()>>();
+}
+
+#[cfg(unix)]
+#[test]
+fn check_unix_symbol_sync() {
+    assert_sync::<libloading::os::unix::Symbol<fn() -> ()>>();
+    // assert_not_sync::<libloading::os::unix::Symbol<*const ()>>();
+}
+
+#[cfg(windows)]
+#[test]
+fn check_windows_symbol_sync() {
+    assert_sync::<libloading::os::windows::Symbol<fn() -> ()>>();
+    // assert_not_sync::<libloading::os::windows::Symbol<*const ()>>();
+}
diff --git a/tests/nagisa32.dll b/tests/nagisa32.dll
new file mode 100644
index 0000000..0a6218a
--- /dev/null
+++ b/tests/nagisa32.dll
Binary files differ
diff --git a/tests/nagisa64.dll b/tests/nagisa64.dll
new file mode 100644
index 0000000..bacaa4b
--- /dev/null
+++ b/tests/nagisa64.dll
Binary files differ
diff --git a/tests/windows.rs b/tests/windows.rs
new file mode 100644
index 0000000..343aaa1
--- /dev/null
+++ b/tests/windows.rs
@@ -0,0 +1,56 @@
+#![cfg(windows)]
+extern crate libloading;
+use libloading::os::windows::*;
+use std::ffi::CStr;
+
+// The ordinal DLL contains exactly one function (other than DllMain, that is) with ordinal number
+// 1. This function has the sugnature `fn() -> *const c_char` and returns a string "bunny\0" (in
+// reference to WindowsBunny).
+//
+// Both x86_64 and x86 versions of the .dll are functionally the same. Ideally we would compile the
+// dlls with well known ordinals from our own testing helpers library, but rustc does not allow
+// specifying a custom .def file (https://github.com/rust-lang/rust/issues/35089)
+//
+// The DLLs were kindly compiled by WindowsBunny (aka. @retep998).
+
+#[cfg(target_arch="x86")]
+fn load_ordinal_lib() -> Library {
+    Library::new("tests/nagisa32.dll").expect("nagisa32.dll")
+}
+
+#[cfg(target_arch="x86_64")]
+fn load_ordinal_lib() -> Library {
+    Library::new("tests/nagisa64.dll").expect("nagisa64.dll")
+}
+
+#[cfg(any(target_arch="x86", target_arch="x86_64"))]
+#[test]
+fn test_ordinal() {
+    let lib = load_ordinal_lib();
+    unsafe {
+        let windows: Symbol<unsafe fn() -> *const i8> = lib.get_ordinal(1).expect("function");
+        assert_eq!(CStr::from_ptr(windows()).to_bytes(), b"bunny");
+    }
+}
+
+#[cfg(any(target_arch="x86", target_arch="x86_64"))]
+#[test]
+fn test_ordinal_missing_fails() {
+    let lib = load_ordinal_lib();
+    unsafe {
+        let r: Result<Symbol<unsafe fn() -> *const i8>, _> = lib.get_ordinal(2);
+        r.err().unwrap();
+        let r: Result<Symbol<unsafe fn() -> *const i8>, _> = lib.get_ordinal(!0);
+        r.err().unwrap();
+    }
+}
+
+#[test]
+fn test_new_kernel23() {
+    Library::new("kernel23").err().unwrap();
+}
+
+#[test]
+fn test_new_kernel32_no_ext() {
+    Library::new("kernel32").unwrap();
+}