diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index d9df2f20d5..ed104b624c 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -33,10 +33,11 @@ jobs:
     - name: Install Rust (rustup)
       run: rustup update ${{ matrix.rust }} --no-self-update && rustup default ${{ matrix.rust }}
       shell: bash
-    - run: cargo test --locked
-    - run: cargo test --features https,ssh
     - run: cargo run -p systest
     - run: cargo run -p systest --features unstable-sha256
+    - run: cargo test --locked
+    - run: cargo test --features https,ssh
+    - run: cargo test --features unstable-sha256
     - run: cargo test -p git2-curl
 
   rustfmt:
diff --git a/Cargo.toml b/Cargo.toml
index aaac74bac5..3a56de05ea 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -34,6 +34,18 @@ url = "2.5.4"
 
 [features]
 unstable = []
+# Experimental SHA256 OID support,
+# reflecting upstream libgit2's GIT_EXPERIMENTAL_SHA256.
+#
+# This is an ABI-breaking change.
+# Future releases with this feature may introduce breakages without notice
+# Use at your own risk.
+#
+# Library authors:
+# DO NOT enable this feature by default in your dependencies.
+# Due to Cargo's additive features,
+# downstream users cannot deactivate it once enabled.
+unstable-sha256 = ["libgit2-sys/unstable-sha256"]
 default = []
 ssh = ["libgit2-sys/ssh", "cred"]
 https = ["libgit2-sys/https", "openssl-sys", "openssl-probe", "cred"]
diff --git a/examples/diff.rs b/examples/diff.rs
index 7440149ba0..afc0767a5a 100644
--- a/examples/diff.rs
+++ b/examples/diff.rs
@@ -319,7 +319,13 @@ fn tree_to_treeish<'a>(
 
 fn resolve_blob<'a>(repo: &'a Repository, arg: Option<&String>) -> Result<Option<Blob<'a>>, Error> {
     let arg = match arg {
-        Some(s) => Oid::from_str(s)?,
+        Some(s) => {
+            #[cfg(not(feature = "unstable-sha256"))]
+            let oid = Oid::from_str(s)?;
+            #[cfg(feature = "unstable-sha256")]
+            let oid = Oid::from_str(s, repo.object_format())?;
+            oid
+        }
         None => return Ok(None),
     };
     repo.find_blob(arg).map(|b| Some(b))
diff --git a/examples/init.rs b/examples/init.rs
index 3ae79082d7..861bd9d370 100644
--- a/examples/init.rs
+++ b/examples/init.rs
@@ -15,6 +15,7 @@
 #![deny(warnings)]
 
 use clap::Parser;
+use git2::ObjectFormat;
 use git2::{Error, Repository, RepositoryInitMode, RepositoryInitOptions};
 use std::path::{Path, PathBuf};
 
@@ -40,6 +41,9 @@ struct Args {
     #[structopt(name = "perms", long = "shared")]
     /// permissions to create the repository with
     flag_shared: Option<String>,
+    #[structopt(name = "object-format", long, value_parser = parse_object_format)]
+    /// object format to use (sha1 or sha256, requires unstable-sha256 feature)
+    flag_object_format: Option<ObjectFormat>,
 }
 
 fn run(args: &Args) -> Result<(), Error> {
@@ -48,6 +52,7 @@ fn run(args: &Args) -> Result<(), Error> {
         && args.flag_template.is_none()
         && args.flag_shared.is_none()
         && args.flag_separate_git_dir.is_none()
+        && args.flag_object_format.is_none()
     {
         Repository::init(&path)?
     } else {
@@ -68,6 +73,12 @@ fn run(args: &Args) -> Result<(), Error> {
         if let Some(ref s) = args.flag_shared {
             opts.mode(parse_shared(s)?);
         }
+
+        #[cfg(feature = "unstable-sha256")]
+        if let Some(format) = args.flag_object_format {
+            opts.object_format(format);
+        }
+
         Repository::init_opts(&path, &opts)?
     };
 
@@ -136,6 +147,15 @@ fn parse_shared(shared: &str) -> Result<RepositoryInitMode, Error> {
     }
 }
 
+fn parse_object_format(format: &str) -> Result<ObjectFormat, Error> {
+    match format {
+        "sha1" => Ok(ObjectFormat::Sha1),
+        #[cfg(feature = "unstable-sha256")]
+        "sha256" => Ok(ObjectFormat::Sha256),
+        _ => Err(Error::from_str("object format must be 'sha1' or 'sha256'")),
+    }
+}
+
 fn main() {
     let args = Args::parse();
     match run(&args) {
diff --git a/libgit2-sys/build.rs b/libgit2-sys/build.rs
index 0803601af2..52644f5802 100644
--- a/libgit2-sys/build.rs
+++ b/libgit2-sys/build.rs
@@ -254,11 +254,11 @@ The build is now aborting. To disable, unset the variable or use `LIBGIT2_NO_VEN
         features.push_str("#define GIT_HTTPS 1\n");
 
         if windows {
-            features.push_str("#define GIT_WINHTTP 1\n");
+            features.push_str("#define GIT_HTTPS_WINHTTP 1\n");
         } else if target.contains("apple") {
-            features.push_str("#define GIT_SECURE_TRANSPORT 1\n");
+            features.push_str("#define GIT_HTTPS_SECURETRANSPORT 1\n");
         } else {
-            features.push_str("#define GIT_OPENSSL 1\n");
+            features.push_str("#define GIT_HTTPS_OPENSSL 1\n");
             if let Some(path) = env::var_os("DEP_OPENSSL_INCLUDE") {
                 cfg.include(path);
             }
@@ -266,7 +266,7 @@ The build is now aborting. To disable, unset the variable or use `LIBGIT2_NO_VEN
     }
 
     // Use the CollisionDetection SHA1 implementation.
-    features.push_str("#define GIT_SHA1_COLLISIONDETECT 1\n");
+    features.push_str("#define GIT_SHA1_BUILTIN 1\n");
     cfg.define("SHA1DC_NO_STANDARD_INCLUDES", "1");
     cfg.define("SHA1DC_CUSTOM_INCLUDE_SHA1_C", "\"common.h\"");
     cfg.define("SHA1DC_CUSTOM_INCLUDE_UBC_CHECK_C", "\"common.h\"");
diff --git a/libgit2-sys/lib.rs b/libgit2-sys/lib.rs
index fd40bba7fa..a86732f3e6 100644
--- a/libgit2-sys/lib.rs
+++ b/libgit2-sys/lib.rs
@@ -5,6 +5,14 @@
 extern crate libz_sys as libz;
 
 use libc::{c_char, c_int, c_uchar, c_uint, c_ushort, c_void, size_t};
+
+// libc does not expose mode_t on Windows; use a local alias instead.
+// libgit2 add shims for that, see <libgit2-sys/libgit2/src/util/win32/msvc-compat.h>
+#[cfg(unix)]
+use libc::mode_t;
+#[cfg(not(unix))]
+#[allow(non_camel_case_types)]
+type mode_t = c_uint;
 #[cfg(feature = "ssh")]
 use libssh2_sys as libssh2;
 use std::ffi::CStr;
@@ -839,8 +847,6 @@ git_enum! {
         GIT_OBJECT_TREE = 2,
         GIT_OBJECT_BLOB = 3,
         GIT_OBJECT_TAG = 4,
-        GIT_OBJECT_OFS_DELTA = 6,
-        GIT_OBJECT_REF_DELTA = 7,
     }
 }
 
@@ -1164,6 +1170,7 @@ pub struct git_repository_init_options {
     pub origin_url: *const c_char,
     #[cfg(feature = "unstable-sha256")]
     pub oid_type: git_oid_t,
+    pub refdb_type: git_refdb_t,
 }
 
 pub const GIT_REPOSITORY_INIT_OPTIONS_VERSION: c_uint = 1;
@@ -1236,10 +1243,10 @@ git_enum! {
     pub enum git_repository_init_flag_t {
         GIT_REPOSITORY_INIT_BARE              = 1 << 0,
         GIT_REPOSITORY_INIT_NO_REINIT         = 1 << 1,
-        GIT_REPOSITORY_INIT_NO_DOTGIT_DIR     = 1 << 2,
         GIT_REPOSITORY_INIT_MKDIR             = 1 << 3,
         GIT_REPOSITORY_INIT_MKPATH            = 1 << 4,
         GIT_REPOSITORY_INIT_EXTERNAL_TEMPLATE = 1 << 5,
+        GIT_REPOSITORY_INIT_RELATIVE_GITLINK  = 1 << 6,
     }
 }
 
@@ -1375,6 +1382,12 @@ git_enum! {
     }
 }
 
+git_enum! {
+    pub enum git_refdb_t {
+        GIT_REFDB_FILES = 1,
+    }
+}
+
 git_enum! {
     pub enum git_diff_format_t {
         GIT_DIFF_FORMAT_PATCH = 1,
@@ -1816,6 +1829,7 @@ pub struct git_odb_writepack {
 #[repr(C)]
 pub struct git_refdb_backend {
     pub version: c_uint,
+    pub init: Option<extern "C" fn(*mut git_refdb_backend, *const c_char, mode_t, u32) -> c_int>,
     pub exists: Option<extern "C" fn(*mut c_int, *mut git_refdb_backend, *const c_char) -> c_int>,
     pub lookup: Option<
         extern "C" fn(*mut *mut git_reference, *mut git_refdb_backend, *const c_char) -> c_int,
@@ -2320,10 +2334,9 @@ extern "C" {
     pub fn git_libgit2_shutdown() -> c_int;
 
     // repository
-    #[cfg(not(feature = "unstable-sha256"))]
     pub fn git_repository_new(out: *mut *mut git_repository) -> c_int;
     #[cfg(feature = "unstable-sha256")]
-    pub fn git_repository_new(
+    pub fn git_repository_new_ext(
         out: *mut *mut git_repository,
         opts: *mut git_repository_new_options,
     ) -> c_int;
@@ -2495,28 +2508,25 @@ extern "C" {
     pub fn git_object_typeisloose(kind: git_object_t) -> c_int;
 
     // oid
-    #[cfg(not(feature = "unstable-sha256"))]
+    // These always parse as SHA1
     pub fn git_oid_fromraw(out: *mut git_oid, raw: *const c_uchar) -> c_int;
-    #[cfg(not(feature = "unstable-sha256"))]
     pub fn git_oid_fromstrn(out: *mut git_oid, str: *const c_char, len: size_t) -> c_int;
-    #[cfg(not(feature = "unstable-sha256"))]
     pub fn git_oid_fromstr(out: *mut git_oid, str: *const c_char) -> c_int;
-    #[cfg(not(feature = "unstable-sha256"))]
     pub fn git_oid_fromstrp(out: *mut git_oid, str: *const c_char) -> c_int;
 
+    // These take an explicit OID type (SHA1 or SHA256)
     #[cfg(feature = "unstable-sha256")]
-    pub fn git_oid_fromraw(out: *mut git_oid, raw: *const c_uchar, oid_type: git_oid_t) -> c_int;
+    pub fn git_oid_from_raw(out: *mut git_oid, raw: *const c_uchar, oid_type: git_oid_t) -> c_int;
     #[cfg(feature = "unstable-sha256")]
-    pub fn git_oid_fromstrn(
+    pub fn git_oid_from_prefix(
         out: *mut git_oid,
         str: *const c_char,
         len: size_t,
         oid_type: git_oid_t,
     ) -> c_int;
     #[cfg(feature = "unstable-sha256")]
-    pub fn git_oid_fromstr(out: *mut git_oid, str: *const c_char, oid_type: git_oid_t) -> c_int;
-    #[cfg(feature = "unstable-sha256")]
-    pub fn git_oid_fromstrp(out: *mut git_oid, str: *const c_char, oid_type: git_oid_t) -> c_int;
+    pub fn git_oid_from_string(out: *mut git_oid, str: *const c_char, oid_type: git_oid_t)
+        -> c_int;
 
     pub fn git_oid_tostr(out: *mut c_char, n: size_t, id: *const git_oid) -> *mut c_char;
     pub fn git_oid_cmp(a: *const git_oid, b: *const git_oid) -> c_int;
@@ -2642,6 +2652,7 @@ extern "C" {
         size: *mut size_t,
         remote: *mut git_remote,
     ) -> c_int;
+    pub fn git_remote_oid_type(out: *mut git_oid_t, remote: *mut git_remote) -> c_int;
     pub fn git_remote_set_autotag(
         repo: *mut git_repository,
         remote: *const c_char,
@@ -3344,14 +3355,12 @@ extern "C" {
         stage: c_int,
     ) -> *const git_index_entry;
     pub fn git_index_has_conflicts(index: *const git_index) -> c_int;
-    #[cfg(not(feature = "unstable-sha256"))]
     pub fn git_index_new(index: *mut *mut git_index) -> c_int;
     #[cfg(feature = "unstable-sha256")]
-    pub fn git_index_new(index: *mut *mut git_index, opts: *const git_index_options) -> c_int;
-    #[cfg(not(feature = "unstable-sha256"))]
+    pub fn git_index_new_ext(index: *mut *mut git_index, opts: *const git_index_options) -> c_int;
     pub fn git_index_open(index: *mut *mut git_index, index_path: *const c_char) -> c_int;
     #[cfg(feature = "unstable-sha256")]
-    pub fn git_index_open(
+    pub fn git_index_open_ext(
         index: *mut *mut git_index,
         index_path: *const c_char,
         opts: *const git_index_options,
@@ -3923,14 +3932,13 @@ extern "C" {
         line_cb: git_diff_line_cb,
         payload: *mut c_void,
     ) -> c_int;
-    #[cfg(not(feature = "unstable-sha256"))]
     pub fn git_diff_from_buffer(
         diff: *mut *mut git_diff,
         content: *const c_char,
         content_len: size_t,
     ) -> c_int;
     #[cfg(feature = "unstable-sha256")]
-    pub fn git_diff_from_buffer(
+    pub fn git_diff_from_buffer_ext(
         diff: *mut *mut git_diff,
         content: *const c_char,
         content_len: size_t,
@@ -4266,14 +4274,12 @@ extern "C" {
 
     // odb
     pub fn git_repository_odb(out: *mut *mut git_odb, repo: *mut git_repository) -> c_int;
-    #[cfg(not(feature = "unstable-sha256"))]
     pub fn git_odb_new(db: *mut *mut git_odb) -> c_int;
     #[cfg(feature = "unstable-sha256")]
-    pub fn git_odb_new(db: *mut *mut git_odb, opts: *const git_odb_options) -> c_int;
-    #[cfg(not(feature = "unstable-sha256"))]
+    pub fn git_odb_new_ext(db: *mut *mut git_odb, opts: *const git_odb_options) -> c_int;
     pub fn git_odb_open(out: *mut *mut git_odb, objects_dir: *const c_char) -> c_int;
     #[cfg(feature = "unstable-sha256")]
-    pub fn git_odb_open(
+    pub fn git_odb_open_ext(
         out: *mut *mut git_odb,
         objects_dir: *const c_char,
         opts: *const git_odb_options,
diff --git a/libgit2-sys/libgit2 b/libgit2-sys/libgit2
index ca225744b9..d908000464 160000
--- a/libgit2-sys/libgit2
+++ b/libgit2-sys/libgit2
@@ -1 +1 @@
-Subproject commit ca225744b992bf2bf24e9a2eb357ddef78179667
+Subproject commit d90800046420c694f93285600f3d325c38ed2691
diff --git a/src/commit.rs b/src/commit.rs
index ac1f6c1f47..9e0cafdd65 100644
--- a/src/commit.rs
+++ b/src/commit.rs
@@ -437,10 +437,15 @@ mod tests {
         assert_eq!(commit.parents().count(), 0);
 
         let tree_header_bytes = commit.header_field_bytes("tree").unwrap();
-        assert_eq!(
-            crate::Oid::from_str(tree_header_bytes.as_str().unwrap()).unwrap(),
-            commit.tree_id()
-        );
+        let tree_oid = {
+            let str = tree_header_bytes.as_str().unwrap();
+            #[cfg(not(feature = "unstable-sha256"))]
+            let oid = crate::Oid::from_str(str).unwrap();
+            #[cfg(feature = "unstable-sha256")]
+            let oid = crate::Oid::from_str(str, repo.object_format()).unwrap();
+            oid
+        };
+        assert_eq!(tree_oid, commit.tree_id());
         assert_eq!(commit.author().name(), Some("name"));
         assert_eq!(commit.author().email(), Some("email"));
         assert_eq!(commit.committer().name(), Some("name"));
@@ -467,4 +472,45 @@ mod tests {
             .ok()
             .unwrap();
     }
+
+    #[test]
+    #[cfg(feature = "unstable-sha256")]
+    fn smoke_sha256() {
+        let (_td, repo) = crate::test::repo_init_sha256();
+        let head = repo.head().unwrap();
+        let target = head.target().unwrap();
+        let commit = repo.find_commit(target).unwrap();
+
+        // Verify SHA256 OID (32 bytes)
+        assert_eq!(commit.id().as_bytes().len(), 32);
+        assert_eq!(commit.tree_id().as_bytes().len(), 32);
+
+        assert_eq!(commit.message(), Some("initial\n\nbody"));
+        assert_eq!(commit.body(), Some("body"));
+        assert_eq!(commit.id(), target);
+        commit.summary().unwrap();
+        commit.tree().unwrap();
+        assert_eq!(commit.parents().count(), 0);
+
+        let tree_header_bytes = commit.header_field_bytes("tree").unwrap();
+        let tree_oid = {
+            let str = tree_header_bytes.as_str().unwrap();
+            let oid = crate::Oid::from_str(str, repo.object_format()).unwrap();
+            oid
+        };
+        assert_eq!(tree_oid, commit.tree_id());
+
+        // Create child commit with parent
+        let sig = repo.signature().unwrap();
+        let tree = repo.find_tree(commit.tree_id()).unwrap();
+        let id = repo
+            .commit(Some("HEAD"), &sig, &sig, "bar", &tree, &[&commit])
+            .unwrap();
+        let head = repo.find_commit(id).unwrap();
+
+        // Verify child commit ID is also SHA256
+        assert_eq!(head.id().as_bytes().len(), 32);
+        assert_eq!(head.parent_count(), 1);
+        assert_eq!(head.parent_id(0).unwrap(), commit.id());
+    }
 }
diff --git a/src/diff.rs b/src/diff.rs
index f65e7b26ba..5e5104cd8f 100644
--- a/src/diff.rs
+++ b/src/diff.rs
@@ -310,16 +310,27 @@ impl Diff<'static> {
     /// two trees, however there may be subtle differences. For example,
     /// a patch file likely contains abbreviated object IDs, so the
     /// object IDs parsed by this function will also be abbreviated.
-    pub fn from_buffer(buffer: &[u8]) -> Result<Diff<'static>, Error> {
+    pub fn from_buffer(
+        buffer: &[u8],
+        #[cfg(feature = "unstable-sha256")] format: crate::ObjectFormat,
+    ) -> Result<Diff<'static>, Error> {
         crate::init();
         let mut diff: *mut raw::git_diff = std::ptr::null_mut();
+        let data = buffer.as_ptr() as *const c_char;
+        let len = buffer.len();
         unsafe {
             // NOTE: Doesn't depend on repo, so lifetime can be 'static
-            try_call!(raw::git_diff_from_buffer(
-                &mut diff,
-                buffer.as_ptr() as *const c_char,
-                buffer.len()
-            ));
+            #[cfg(not(feature = "unstable-sha256"))]
+            try_call!(raw::git_diff_from_buffer(&mut diff, data, len));
+            #[cfg(feature = "unstable-sha256")]
+            {
+                let mut opts: raw::git_diff_parse_options = std::mem::zeroed();
+                opts.version = raw::GIT_DIFF_PARSE_OPTIONS_VERSION;
+                opts.oid_type = format.raw();
+                try_call!(raw::git_diff_from_buffer_ext(
+                    &mut diff, data, len, &mut opts
+                ));
+            }
             Ok(Diff::from_raw(diff))
         }
     }
@@ -1552,6 +1563,8 @@ impl DiffPatchidOptions {
 
 #[cfg(test)]
 mod tests {
+    #[cfg(feature = "unstable-sha256")]
+    use crate::Diff;
     use crate::{DiffLineType, DiffOptions, Oid, Signature, Time};
     use std::borrow::Borrow;
     use std::fs::File;
@@ -1858,4 +1871,37 @@ mod tests {
 
         assert_eq!(result.unwrap_err().code(), crate::ErrorCode::User);
     }
+
+    #[test]
+    #[cfg(feature = "unstable-sha256")]
+    fn diff_sha256() {
+        let (_td, repo) = crate::test::repo_init_sha256();
+        let diff = repo.diff_tree_to_workdir(None, None).unwrap();
+        assert_eq!(diff.deltas().len(), 0);
+        let stats = diff.stats().unwrap();
+        assert_eq!(stats.insertions(), 0);
+        assert_eq!(stats.deletions(), 0);
+        assert_eq!(stats.files_changed(), 0);
+        let patchid = diff.patchid(None).unwrap();
+
+        // Verify SHA256 OID (32 bytes)
+        assert_eq!(patchid.as_bytes().len(), 32);
+    }
+
+    #[test]
+    #[cfg(feature = "unstable-sha256")]
+    fn diff_from_buffer_sha256() {
+        // Minimal patch with SHA256 OID (64 chars)
+        let patch = b"diff --git a/file.txt b/file.txt
+index 0000000000000000000000000000000000000000000000000000000000000000..1111111111111111111111111111111111111111111111111111111111111111 100644
+--- a/file.txt
++++ b/file.txt
+@@ -1 +1 @@
+-old
++new
+";
+
+        let diff = Diff::from_buffer(patch, crate::ObjectFormat::Sha256).unwrap();
+        assert_eq!(diff.deltas().len(), 1);
+    }
 }
diff --git a/src/index.rs b/src/index.rs
index 4f72715584..cdbe8db1c3 100644
--- a/src/index.rs
+++ b/src/index.rs
@@ -90,6 +90,23 @@ impl Index {
     ///
     /// This index object cannot be read/written to the filesystem, but may be
     /// used to perform in-memory index operations.
+    ///
+    /// <div class="warning">
+    ///
+    /// # SHA1-only limitation
+    ///
+    /// This method **always** creates a SHA1 index.
+    ///
+    /// In future releases, this will be removed entirely to avoid misuse.
+    ///
+    /// Consider these alternatives:
+    ///
+    /// * [`Index::with_object_format`] if an in-memory index is needed
+    /// * [`Repository::index`] if you have repository context
+    ///
+    /// </div>
+    #[cfg(not(feature = "unstable-sha256"))]
+    #[deprecated = "this always creates a SHA1 index, consider using `Index::with_object_format`"]
     pub fn new() -> Result<Index, Error> {
         crate::init();
         let mut raw = ptr::null_mut();
@@ -99,6 +116,30 @@ impl Index {
         }
     }
 
+    /// Creates a new in-memory index with the specified object format.
+    ///
+    /// This index object cannot be read/written to the filesystem, but may be
+    /// used to perform in-memory index operations.
+    pub fn with_object_format(format: crate::ObjectFormat) -> Result<Index, Error> {
+        crate::init();
+        let mut raw = ptr::null_mut();
+        unsafe {
+            #[cfg(not(feature = "unstable-sha256"))]
+            {
+                let _ = format;
+                try_call!(raw::git_index_new(&mut raw));
+            }
+            #[cfg(feature = "unstable-sha256")]
+            {
+                let mut opts: raw::git_index_options = std::mem::zeroed();
+                opts.version = raw::GIT_INDEX_OPTIONS_VERSION;
+                opts.oid_type = format.raw();
+                try_call!(raw::git_index_new_ext(&mut raw, &opts));
+            }
+            Ok(Binding::from_raw(raw))
+        }
+    }
+
     /// Create a new bare Git index object as a memory representation of the Git
     /// index file in 'index_path', without a repository to back it.
     ///
@@ -107,13 +148,24 @@ impl Index {
     ///
     /// If you need an index attached to a repository, use the `index()` method
     /// on `Repository`.
-    pub fn open(index_path: &Path) -> Result<Index, Error> {
+    pub fn open(
+        index_path: &Path,
+        #[cfg(feature = "unstable-sha256")] format: crate::ObjectFormat,
+    ) -> Result<Index, Error> {
         crate::init();
         let mut raw = ptr::null_mut();
         // Normal file path OK (does not need Windows conversion).
         let index_path = index_path.into_c_string()?;
         unsafe {
+            #[cfg(not(feature = "unstable-sha256"))]
             try_call!(raw::git_index_open(&mut raw, index_path));
+            #[cfg(feature = "unstable-sha256")]
+            {
+                let mut opts: raw::git_index_options = std::mem::zeroed();
+                opts.version = raw::GIT_INDEX_OPTIONS_VERSION;
+                opts.oid_type = format.raw();
+                try_call!(raw::git_index_open_ext(&mut raw, index_path, &opts));
+            }
             Ok(Binding::from_raw(raw))
         }
     }
@@ -846,11 +898,12 @@ mod tests {
     use std::path::Path;
     use tempfile::TempDir;
 
+    use crate::ObjectFormat;
     use crate::{ErrorCode, Index, IndexEntry, IndexTime, Oid, Repository, ResetType};
 
     #[test]
     fn smoke() {
-        let mut index = Index::new().unwrap();
+        let mut index = Index::with_object_format(ObjectFormat::Sha1).unwrap();
         assert!(index.add_path(&Path::new(".")).is_err());
         index.clear().unwrap();
         assert_eq!(index.len(), 0);
@@ -867,7 +920,10 @@ mod tests {
             index.path().map(|s| s.to_path_buf()),
             Some(repo.path().join("index"))
         );
+        #[cfg(not(feature = "unstable-sha256"))]
         Index::open(&repo.path().join("index")).unwrap();
+        #[cfg(feature = "unstable-sha256")]
+        Index::open(&repo.path().join("index"), ObjectFormat::Sha1).unwrap();
 
         index.clear().unwrap();
         index.read(true).unwrap();
@@ -949,7 +1005,7 @@ mod tests {
 
     #[test]
     fn add_then_read() {
-        let mut index = Index::new().unwrap();
+        let mut index = Index::with_object_format(ObjectFormat::Sha1).unwrap();
         let mut e = entry();
         e.path = b"foobar".to_vec();
         index.add(&e).unwrap();
@@ -959,7 +1015,7 @@ mod tests {
 
     #[test]
     fn add_then_find() {
-        let mut index = Index::new().unwrap();
+        let mut index = Index::with_object_format(ObjectFormat::Sha1).unwrap();
         let mut e = entry();
         e.path = b"foo/bar".to_vec();
         index.add(&e).unwrap();
@@ -1004,10 +1060,38 @@ mod tests {
             uid: 0,
             gid: 0,
             file_size: 0,
+            #[cfg(not(feature = "unstable-sha256"))]
             id: Oid::from_bytes(&[0; 20]).unwrap(),
+            #[cfg(feature = "unstable-sha256")]
+            id: Oid::from_bytes(&[0; 32]).unwrap(),
             flags: 0,
             flags_extended: 0,
             path: Vec::new(),
         }
     }
+
+    #[test]
+    #[cfg(feature = "unstable-sha256")]
+    fn index_sha256() {
+        let (_td, repo) = crate::test::repo_init_sha256();
+        let mut index = repo.index().unwrap();
+
+        // Test opening with correct format
+        Index::open(&repo.path().join("index"), ObjectFormat::Sha256).unwrap();
+
+        // Test basic operations with SHA256
+        index.clear().unwrap();
+        index.read(true).unwrap();
+        index.write().unwrap();
+        let tree_id = index.write_tree().unwrap();
+
+        // Verify OID is 32 bytes (SHA256)
+        assert_eq!(tree_id.as_bytes().len(), 32);
+    }
+
+    #[test]
+    #[cfg(feature = "unstable-sha256")]
+    fn smooke_in_memory_index_sha256() {
+        let _index = Index::with_object_format(ObjectFormat::Sha256).unwrap();
+    }
 }
diff --git a/src/indexer.rs b/src/indexer.rs
index 3a3ff62a5a..e07a97a5d5 100644
--- a/src/indexer.rs
+++ b/src/indexer.rs
@@ -123,7 +123,13 @@ impl<'a> Indexer<'a> {
     /// `mode` is the permissions to use for the output files, use `0` for defaults.
     ///
     /// If `verify` is `false`, the indexer will bypass object connectivity checks.
-    pub fn new(odb: Option<&Odb<'a>>, path: &Path, mode: u32, verify: bool) -> Result<Self, Error> {
+    pub fn new(
+        odb: Option<&Odb<'a>>,
+        path: &Path,
+        mode: u32,
+        verify: bool,
+        #[cfg(feature = "unstable-sha256")] format: crate::ObjectFormat,
+    ) -> Result<Self, Error> {
         crate::init();
         let path = path.into_c_string()?;
 
@@ -144,7 +150,17 @@ impl<'a> Indexer<'a> {
             opts.progress_cb_payload = progress_payload_ptr as *mut c_void;
             opts.verify = verify.into();
 
+            #[cfg(feature = "unstable-sha256")]
+            {
+                opts.mode = mode;
+                opts.oid_type = format.raw();
+                opts.odb = odb;
+            }
+
+            #[cfg(not(feature = "unstable-sha256"))]
             try_call!(raw::git_indexer_new(&mut out, path, mode, odb, &mut opts));
+            #[cfg(feature = "unstable-sha256")]
+            try_call!(raw::git_indexer_new(&mut out, path, &mut opts));
         }
 
         Ok(Self {
@@ -238,6 +254,46 @@ mod tests {
             repo_target.path().join("objects").join("pack").as_path(),
             0o644,
             true,
+            #[cfg(feature = "unstable-sha256")]
+            crate::ObjectFormat::Sha1,
+        )
+        .unwrap();
+        indexer.progress(|_| {
+            progress_called = true;
+            true
+        });
+        indexer.write(&buf).unwrap();
+        indexer.commit().unwrap();
+
+        // Assert that target repo picks it up as valid
+        let commit_target = repo_target.find_commit(commit_source_id).unwrap();
+        assert_eq!(commit_target.id(), commit_source_id);
+        assert!(progress_called);
+    }
+
+    #[test]
+    #[cfg(feature = "unstable-sha256")]
+    fn indexer_sha256() {
+        let (_td, repo_source) = crate::test::repo_init_sha256();
+        let (_td, repo_target) = crate::test::repo_init_sha256();
+
+        let mut progress_called = false;
+
+        // Create an in-memory packfile
+        let mut builder = t!(repo_source.packbuilder());
+        let mut buf = Buf::new();
+        let (commit_source_id, _tree) = crate::test::commit(&repo_source);
+        t!(builder.insert_object(commit_source_id, None));
+        t!(builder.write_buf(&mut buf));
+
+        // Write it to the standard location in the target repo, but via indexer
+        let odb = repo_source.odb().unwrap();
+        let mut indexer = Indexer::new(
+            Some(&odb),
+            repo_target.path().join("objects").join("pack").as_path(),
+            0o644,
+            true,
+            crate::ObjectFormat::Sha256,
         )
         .unwrap();
         indexer.progress(|_| {
diff --git a/src/odb.rs b/src/odb.rs
index e48d3600fc..805d00b258 100644
--- a/src/odb.rs
+++ b/src/odb.rs
@@ -45,6 +45,17 @@ impl<'repo> Drop for Odb<'repo> {
 
 impl<'repo> Odb<'repo> {
     /// Creates an object database without any backends.
+    ///
+    /// <div class="warning">
+    ///
+    /// # SHA1-only limitation
+    ///
+    /// This method **always** creates a SHA1 object database.
+    ///
+    /// In future releases, this method will be removed entirely.
+    ///
+    /// </div>
+    #[cfg(not(feature = "unstable-sha256"))]
     pub fn new<'a>() -> Result<Odb<'a>, Error> {
         crate::init();
         unsafe {
@@ -54,6 +65,25 @@ impl<'repo> Odb<'repo> {
         }
     }
 
+    /// Creates an object database without any backends, with the specified object format.
+    ///
+    /// The `format` parameter determines the OID type (SHA1 or SHA256) used by this object database.
+    ///
+    /// Note: Most users should obtain an ODB from [`Repository::odb`](crate::Repository::odb),
+    /// which automatically inherits the repository's object format.
+    #[cfg(feature = "unstable-sha256")]
+    pub fn with_object_format<'a>(format: crate::ObjectFormat) -> Result<Odb<'a>, Error> {
+        crate::init();
+        unsafe {
+            let mut out = ptr::null_mut();
+            let mut opts: raw::git_odb_options = std::mem::zeroed();
+            opts.version = raw::GIT_ODB_OPTIONS_VERSION;
+            opts.oid_type = format.raw();
+            try_call!(raw::git_odb_new_ext(&mut out, &opts));
+            Ok(Odb::from_raw(out))
+        }
+    }
+
     /// Create object database reading stream.
     ///
     /// Note that most backends do not support streaming reads because they store their objects as compressed/delta'ed blobs.
@@ -239,7 +269,10 @@ impl<'repo> Odb<'repo> {
     /// ```compile_fail
     /// use git2::Odb;
     /// let mempack = {
+    ///     #[cfg(not(feature = "unstable-sha256"))]
     ///     let odb = Odb::new().unwrap();
+    ///     #[cfg(feature = "unstable-sha256")]
+    ///     let odb = Odb::with_object_format(git2::ObjectFormat::Sha1).unwrap();
     ///     odb.add_new_mempack_backend(1000).unwrap()
     /// };
     /// ```
@@ -635,7 +668,13 @@ mod tests {
         let db = repo.odb().unwrap();
         let id = db.write(ObjectType::Blob, &dat).unwrap();
         let id_prefix_str = &id.to_string()[0..10];
-        let id_prefix = Oid::from_str(id_prefix_str).unwrap();
+        let id_prefix = {
+            #[cfg(not(feature = "unstable-sha256"))]
+            let oid = Oid::from_str(id_prefix_str).unwrap();
+            #[cfg(feature = "unstable-sha256")]
+            let oid = Oid::from_str(id_prefix_str, repo.object_format()).unwrap();
+            oid
+        };
         let found_oid = db.exists_prefix(id_prefix, 10).unwrap();
         assert_eq!(found_oid, id);
     }
diff --git a/src/oid.rs b/src/oid.rs
index d1156e50d1..66ca1dbf71 100644
--- a/src/oid.rs
+++ b/src/oid.rs
@@ -13,6 +13,9 @@ use crate::util::{c_cmp_to_ordering, Binding};
 pub enum ObjectFormat {
     /// SHA1 object format (20-byte object IDs)
     Sha1,
+    /// SHA256 object format (32-byte object IDs)
+    #[cfg(feature = "unstable-sha256")]
+    Sha256,
 }
 
 impl Binding for ObjectFormat {
@@ -21,6 +24,8 @@ impl Binding for ObjectFormat {
     unsafe fn from_raw(raw: raw::git_oid_t) -> Self {
         match raw {
             raw::GIT_OID_SHA1 => ObjectFormat::Sha1,
+            #[cfg(feature = "unstable-sha256")]
+            raw::GIT_OID_SHA256 => ObjectFormat::Sha256,
             _ => panic!("Unknown git oid type"),
         }
     }
@@ -28,6 +33,8 @@ impl Binding for ObjectFormat {
     fn raw(&self) -> Self::Raw {
         match self {
             ObjectFormat::Sha1 => raw::GIT_OID_SHA1,
+            #[cfg(feature = "unstable-sha256")]
+            ObjectFormat::Sha256 => raw::GIT_OID_SHA256,
         }
     }
 }
@@ -45,34 +52,68 @@ impl Oid {
     /// # Errors
     ///
     /// Returns an error if the string is empty, is longer than 40 hex
-    /// characters, or contains any non-hex characters.
-    pub fn from_str(s: &str) -> Result<Oid, Error> {
+    /// characters (or 64 for SHA256), or contains any non-hex characters.
+    pub fn from_str(
+        s: &str,
+        #[cfg(feature = "unstable-sha256")] format: crate::ObjectFormat,
+    ) -> Result<Oid, Error> {
         crate::init();
         let mut raw = crate::util::zeroed_raw_oid();
+        let data = s.as_bytes().as_ptr() as *const libc::c_char;
+        let len = s.len() as libc::size_t;
         unsafe {
-            try_call!(raw::git_oid_fromstrn(
-                &mut raw,
-                s.as_bytes().as_ptr() as *const libc::c_char,
-                s.len() as libc::size_t
-            ));
+            #[cfg(not(feature = "unstable-sha256"))]
+            try_call!(raw::git_oid_fromstrn(&mut raw, data, len));
+            #[cfg(feature = "unstable-sha256")]
+            try_call!(raw::git_oid_from_prefix(&mut raw, data, len, format.raw()));
         }
         Ok(Oid { raw })
     }
 
     /// Parse a raw object id into an Oid structure.
     ///
-    /// If the array given is not 20 bytes in length, an error is returned.
+    /// When the `unstable-sha256` feature is enabled, this automatically detects
+    /// the OID type based on byte length:
+    ///
+    /// - 20-byte arrays are parsed as SHA1
+    /// - 32-byte arrays are parsed as SHA256
+    ///
+    /// Without the feature, only 20-byte SHA1 OIDs are supported.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the byte array is not a valid OID length.
     pub fn from_bytes(bytes: &[u8]) -> Result<Oid, Error> {
         crate::init();
         let mut raw = crate::util::zeroed_raw_oid();
-        if bytes.len() != raw::GIT_OID_MAX_SIZE {
-            Err(Error::from_str("raw byte array must be 20 bytes"))
-        } else {
+
+        #[cfg(not(feature = "unstable-sha256"))]
+        {
+            if bytes.len() != raw::GIT_OID_SHA1_SIZE {
+                return Err(Error::from_str("raw byte array must be 20 bytes"));
+            }
             unsafe {
                 try_call!(raw::git_oid_fromraw(&mut raw, bytes.as_ptr()));
             }
-            Ok(Oid { raw })
         }
+
+        #[cfg(feature = "unstable-sha256")]
+        {
+            let oid_type = match bytes.len() {
+                raw::GIT_OID_SHA1_SIZE => raw::GIT_OID_SHA1,
+                raw::GIT_OID_SHA256_SIZE => raw::GIT_OID_SHA256,
+                _ => {
+                    return Err(Error::from_str(
+                        "raw byte array must be 20 bytes (SHA1) or 32 bytes (SHA256)",
+                    ))
+                }
+            };
+            unsafe {
+                try_call!(raw::git_oid_from_raw(&mut raw, bytes.as_ptr(), oid_type));
+            }
+        }
+
+        Ok(Oid { raw })
     }
 
     /// Creates an all zero Oid structure.
@@ -85,16 +126,25 @@ impl Oid {
     /// Hashes the provided data as an object of the provided type, and returns
     /// an Oid corresponding to the result. This does not store the object
     /// inside any object database or repository.
-    pub fn hash_object(kind: ObjectType, bytes: &[u8]) -> Result<Oid, Error> {
+    pub fn hash_object(
+        kind: ObjectType,
+        bytes: &[u8],
+        #[cfg(feature = "unstable-sha256")] format: crate::ObjectFormat,
+    ) -> Result<Oid, Error> {
         crate::init();
 
         let mut out = crate::util::zeroed_raw_oid();
+        let data = bytes.as_ptr() as *const libc::c_void;
         unsafe {
+            #[cfg(not(feature = "unstable-sha256"))]
+            try_call!(raw::git_odb_hash(&mut out, data, bytes.len(), kind.raw()));
+            #[cfg(feature = "unstable-sha256")]
             try_call!(raw::git_odb_hash(
                 &mut out,
-                bytes.as_ptr() as *const libc::c_void,
+                data,
                 bytes.len(),
-                kind.raw()
+                kind.raw(),
+                format.raw()
             ));
         }
 
@@ -104,7 +154,11 @@ impl Oid {
     /// Hashes the content of the provided file as an object of the provided type,
     /// and returns an Oid corresponding to the result. This does not store the object
     /// inside any object database or repository.
-    pub fn hash_file<P: AsRef<Path>>(kind: ObjectType, path: P) -> Result<Oid, Error> {
+    pub fn hash_file<P: AsRef<Path>>(
+        kind: ObjectType,
+        path: P,
+        #[cfg(feature = "unstable-sha256")] format: crate::ObjectFormat,
+    ) -> Result<Oid, Error> {
         crate::init();
 
         // Normal file path OK (does not need Windows conversion).
@@ -112,13 +166,24 @@ impl Oid {
 
         let mut out = crate::util::zeroed_raw_oid();
         unsafe {
+            #[cfg(not(feature = "unstable-sha256"))]
             try_call!(raw::git_odb_hashfile(&mut out, rpath, kind.raw()));
+            #[cfg(feature = "unstable-sha256")]
+            try_call!(raw::git_odb_hashfile(
+                &mut out,
+                rpath,
+                kind.raw(),
+                format.raw()
+            ));
         }
 
         Ok(Oid { raw: out })
     }
 
-    /// View this OID as a byte-slice 20 bytes in length.
+    /// View this OID as a byte-slice.
+    ///
+    /// * 20 bytes in length if the feature `unstable-sha256` is not enabled.
+    /// * 32 bytes in length if the feature `unstable-sha256` is enabled.
     pub fn as_bytes(&self) -> &[u8] {
         &self.raw.id
     }
@@ -162,6 +227,7 @@ impl fmt::Display for Oid {
     }
 }
 
+#[cfg(not(feature = "unstable-sha256"))]
 impl str::FromStr for Oid {
     type Err = Error;
 
@@ -171,6 +237,25 @@ impl str::FromStr for Oid {
     ///
     /// Returns an error if the string is empty, is longer than 40 hex
     /// characters, or contains any non-hex characters.
+    ///
+    /// <div class="warning">
+    ///
+    /// # SHA1-only limitation
+    ///
+    /// This method **always** parses as SHA1 (up to 40 hex characters).
+    /// It cannot parse SHA256 OIDs because [`str::FromStr::from_str`] lacks
+    /// the object format parameter.
+    ///
+    /// In future releases, this will be removed entirely to avoid misuse.
+    ///
+    /// Consider these alternatives:
+    ///
+    /// * [`Oid::from_str`] with explicit [`ObjectFormat`](crate::ObjectFormat)
+    /// * [`Oid::from_bytes`] if you have access to the underlying byte of the OID
+    /// * [`Repository::revparse_single`](crate::Repository::revparse_single)
+    ///   if you have repository context
+    ///
+    /// </div>
     fn from_str(s: &str) -> Result<Oid, Error> {
         Oid::from_str(s)
     }
@@ -212,12 +297,15 @@ mod tests {
     use std::fs::File;
     use std::io::prelude::*;
 
+    use libgit2_sys as raw;
+
     use super::Error;
     use super::Oid;
     use crate::ObjectType;
     use tempfile::TempDir;
 
     #[test]
+    #[cfg(not(feature = "unstable-sha256"))]
     fn conversions() {
         assert!(Oid::from_str("foo").is_err());
         assert!(Oid::from_str("decbf2be529ab6557d5429922251e5ee36519817").is_ok());
@@ -226,6 +314,46 @@ mod tests {
     }
 
     #[test]
+    #[cfg(feature = "unstable-sha256")]
+    fn conversions_object_format() {
+        use crate::ObjectFormat;
+
+        assert!(Oid::from_str("foo", ObjectFormat::Sha1).is_err());
+        assert!(Oid::from_str(
+            "decbf2be529ab6557d5429922251e5ee36519817",
+            ObjectFormat::Sha1
+        )
+        .is_ok());
+
+        assert!(Oid::from_str("foo", ObjectFormat::Sha256).is_err());
+        assert!(Oid::from_str(
+            "1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
+            ObjectFormat::Sha256
+        )
+        .is_ok());
+
+        assert!(Oid::from_bytes(b"foo").is_err());
+
+        let sha1_from_bytes = Oid::from_bytes(&[0u8; 20]).unwrap();
+        let sha256_from_bytes = Oid::from_bytes(&[0u8; 32]).unwrap();
+
+        // Both stored in 32-byte arrays when sha256 feature is enabled
+        assert_eq!(sha1_from_bytes.as_bytes().len(), raw::GIT_OID_MAX_SIZE);
+        assert_eq!(sha256_from_bytes.as_bytes().len(), raw::GIT_OID_MAX_SIZE);
+
+        // Hex string output should differ based on OID type
+        assert_eq!(sha1_from_bytes.to_string().len(), raw::GIT_OID_SHA1_HEXSIZE);
+        assert_eq!(
+            sha256_from_bytes.to_string().len(),
+            raw::GIT_OID_SHA256_HEXSIZE
+        );
+
+        // Verify they're not equal despite being all zeros
+        assert_ne!(sha1_from_bytes, sha256_from_bytes);
+    }
+
+    #[test]
+    #[cfg(not(feature = "unstable-sha256"))]
     fn comparisons() -> Result<(), Error> {
         assert_eq!(Oid::from_str("decbf2b")?, Oid::from_str("decbf2b")?);
         assert!(Oid::from_str("decbf2b")? <= Oid::from_str("decbf2b")?);
@@ -244,10 +372,110 @@ mod tests {
             Oid::from_bytes(b"00000000000000000000")? < Oid::from_bytes(b"00000000000000000001")?
         );
         assert!(Oid::from_bytes(b"00000000000000000000")? < Oid::from_str("decbf2b")?);
+
+        Ok(())
+    }
+
+    #[test]
+    #[cfg(feature = "unstable-sha256")]
+    fn comparisons_object_format() -> Result<(), Error> {
+        use crate::ObjectFormat;
+
+        // SHA1 OID comparisons with explicit format
+        assert_eq!(
+            Oid::from_str("decbf2b", ObjectFormat::Sha1)?,
+            Oid::from_str("decbf2b", ObjectFormat::Sha1)?
+        );
+        assert!(
+            Oid::from_str("decbf2b", ObjectFormat::Sha1)?
+                <= Oid::from_str("decbf2b", ObjectFormat::Sha1)?
+        );
+        assert!(
+            Oid::from_str("decbf2b", ObjectFormat::Sha1)?
+                >= Oid::from_str("decbf2b", ObjectFormat::Sha1)?
+        );
+        {
+            let o = Oid::from_str("decbf2b", ObjectFormat::Sha1)?;
+            assert_eq!(o, o);
+            assert!(o <= o);
+            assert!(o >= o);
+        }
+        assert_eq!(
+            Oid::from_str("decbf2b", ObjectFormat::Sha1)?,
+            Oid::from_str(
+                "decbf2b000000000000000000000000000000000",
+                ObjectFormat::Sha1
+            )?
+        );
+
+        // SHA1 byte comparisons (20 bytes)
+        assert!(
+            Oid::from_bytes(b"00000000000000000000")? < Oid::from_bytes(b"00000000000000000001")?
+        );
+        assert!(
+            Oid::from_bytes(b"00000000000000000000")?
+                < Oid::from_str("decbf2b", ObjectFormat::Sha1)?
+        );
+
+        // SHA256 OID comparisons with explicit format (using full 64-char hex strings)
         assert_eq!(
-            Oid::from_bytes(b"00000000000000000000")?,
-            Oid::from_str("3030303030303030303030303030303030303030")?
+            Oid::from_str(
+                "abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890",
+                ObjectFormat::Sha256
+            )?,
+            Oid::from_str(
+                "abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890",
+                ObjectFormat::Sha256
+            )?
+        );
+        assert!(
+            Oid::from_str(
+                "abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890",
+                ObjectFormat::Sha256
+            )? <= Oid::from_str(
+                "abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890",
+                ObjectFormat::Sha256
+            )?
         );
+        assert!(
+            Oid::from_str(
+                "abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890",
+                ObjectFormat::Sha256
+            )? >= Oid::from_str(
+                "abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890",
+                ObjectFormat::Sha256
+            )?
+        );
+        {
+            let o = Oid::from_str(
+                "abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890",
+                ObjectFormat::Sha256,
+            )?;
+            assert_eq!(o, o);
+            assert!(o <= o);
+            assert!(o >= o);
+        }
+        assert_eq!(
+            Oid::from_str("abcdef12", ObjectFormat::Sha256)?,
+            Oid::from_str(
+                "abcdef1200000000000000000000000000000000000000000000000000000000",
+                ObjectFormat::Sha256
+            )?
+        );
+
+        // SHA256 byte comparisons (32 bytes)
+        assert!(
+            Oid::from_bytes(b"00000000000000000000000000000000")?
+                < Oid::from_bytes(b"00000000000000000000000000000001")?
+        );
+        assert!(
+            Oid::from_bytes(b"00000000000000000000000000000000")?
+                < Oid::from_str(
+                    "abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890",
+                    ObjectFormat::Sha256
+                )?
+        );
+
         Ok(())
     }
 
@@ -257,17 +485,68 @@ mod tests {
     }
 
     #[test]
+    #[cfg(not(feature = "unstable-sha256"))]
     fn hash_object() {
         let bytes = "Hello".as_bytes();
-        assert!(Oid::hash_object(ObjectType::Blob, bytes).is_ok());
+        let oid = Oid::hash_object(ObjectType::Blob, bytes).unwrap();
+        assert_eq!(oid.to_string().len(), raw::GIT_OID_SHA1_HEXSIZE);
+        assert_eq!(oid.as_bytes().len(), raw::GIT_OID_MAX_SIZE);
     }
 
     #[test]
+    #[cfg(feature = "unstable-sha256")]
+    fn hash_object_with_format() -> Result<(), Error> {
+        use crate::ObjectFormat;
+
+        let bytes = b"hello world";
+
+        let sha1_oid = Oid::hash_object(ObjectType::Blob, bytes, ObjectFormat::Sha1)?;
+        assert_eq!(sha1_oid.to_string().len(), raw::GIT_OID_SHA1_HEXSIZE);
+        assert_eq!(sha1_oid.as_bytes().len(), raw::GIT_OID_MAX_SIZE);
+
+        let sha256_oid = Oid::hash_object(ObjectType::Blob, bytes, ObjectFormat::Sha256)?;
+        assert_eq!(sha256_oid.to_string().len(), raw::GIT_OID_SHA256_HEXSIZE);
+        assert_eq!(sha256_oid.as_bytes().len(), raw::GIT_OID_MAX_SIZE);
+
+        // Different formats produce different OIDs
+        assert_ne!(sha1_oid, sha256_oid);
+
+        Ok(())
+    }
+
+    #[test]
+    #[cfg(not(feature = "unstable-sha256"))]
     fn hash_file() {
         let td = TempDir::new().unwrap();
         let path = td.path().join("hello.txt");
         let mut file = File::create(&path).unwrap();
         file.write_all("Hello".as_bytes()).unwrap();
-        assert!(Oid::hash_file(ObjectType::Blob, &path).is_ok());
+        let oid = Oid::hash_file(ObjectType::Blob, &path).unwrap();
+        assert_eq!(oid.to_string().len(), raw::GIT_OID_SHA1_HEXSIZE);
+        assert_eq!(oid.as_bytes().len(), raw::GIT_OID_MAX_SIZE);
+    }
+
+    #[test]
+    #[cfg(feature = "unstable-sha256")]
+    fn hash_file_object_format() -> Result<(), Error> {
+        use crate::ObjectFormat;
+
+        let td = TempDir::new().unwrap();
+        let path = td.path().join("test.txt");
+        let mut file = File::create(&path).unwrap();
+        file.write_all(b"test content").unwrap();
+
+        let sha1_oid = Oid::hash_object(ObjectType::Blob, b"test content", ObjectFormat::Sha1)?;
+        assert_eq!(sha1_oid.to_string().len(), raw::GIT_OID_SHA1_HEXSIZE);
+        assert_eq!(sha1_oid.as_bytes().len(), raw::GIT_OID_MAX_SIZE);
+
+        let sha256_oid = Oid::hash_object(ObjectType::Blob, b"test content", ObjectFormat::Sha256)?;
+        assert_eq!(sha256_oid.to_string().len(), raw::GIT_OID_SHA256_HEXSIZE);
+        assert_eq!(sha256_oid.as_bytes().len(), raw::GIT_OID_MAX_SIZE);
+
+        // Different formats produce different OIDs
+        assert_ne!(sha1_oid, sha256_oid);
+
+        Ok(())
     }
 }
diff --git a/src/packbuilder.rs b/src/packbuilder.rs
index de47bbce32..f221e793f6 100644
--- a/src/packbuilder.rs
+++ b/src/packbuilder.rs
@@ -293,10 +293,7 @@ extern "C" fn progress_c(
 
 #[cfg(test)]
 mod tests {
-    use crate::{Buf, Oid};
-
-    // hash of a packfile constructed without any objects in it
-    const EMPTY_PACKFILE_OID: &str = "029d08823bd8a8eab510ad6ac75c823cfd3ed31e";
+    use crate::Buf;
 
     fn pack_header(len: u8) -> Vec<u8> {
         [].iter()
@@ -314,8 +311,25 @@ mod tests {
                 0x02, 0x9d, 0x08, 0x82, 0x3b, // ^
                 0xd8, 0xa8, 0xea, 0xb5, 0x10, // | SHA-1 of the zero
                 0xad, 0x6a, 0xc7, 0x5c, 0x82, // | object pack header
-                0x3c, 0xfd, 0x3e, 0xd3, 0x1e,
-            ]) // v
+                0x3c, 0xfd, 0x3e, 0xd3, 0x1e, // v
+            ])
+            .cloned()
+            .collect::<Vec<u8>>()
+    }
+
+    #[cfg(feature = "unstable-sha256")]
+    fn empty_pack_header_sha256() -> Vec<u8> {
+        pack_header(0)
+            .iter()
+            .chain(&[
+                0x7e, 0xd8, 0x90, 0xd8, 0xa4, // ^
+                0x57, 0x60, 0xf3, 0xee, 0xcf, // | SHA-256 of the zero
+                0x73, 0x04, 0x5b, 0x1d, 0x10, // | object pack header
+                0x47, 0x08, 0x5a, 0xf4, 0x77, // |
+                0x6d, 0xc6, 0x83, 0xd7, 0x8e, // |
+                0xac, 0x82, 0x20, 0x3d, 0xf1, // |
+                0x99, 0x3f, // v
+            ])
             .cloned()
             .collect::<Vec<u8>>()
     }
@@ -340,16 +354,46 @@ mod tests {
         assert_eq!(&*buf, &*empty_pack_header());
     }
 
+    #[test]
+    #[cfg(feature = "unstable-sha256")]
+    fn smoke_write_buf_sha256() {
+        let (_td, repo) = crate::test::repo_init_sha256();
+        let mut builder = t!(repo.packbuilder());
+        let mut buf = Buf::new();
+        t!(builder.write_buf(&mut buf));
+        assert!(builder.name().is_none());
+        assert_eq!(&*buf, &*empty_pack_header_sha256());
+    }
+
     #[test]
     fn smoke_write() {
+        // SHA1 hash of a packfile constructed without any objects in it
+        const EMPTY_PACKFILE_OID: &str = "029d08823bd8a8eab510ad6ac75c823cfd3ed31e";
+
         let (_td, repo) = crate::test::repo_init();
         let mut builder = t!(repo.packbuilder());
         t!(builder.write(repo.path(), 0));
+        #[cfg(not(feature = "unstable-sha256"))]
         #[allow(deprecated)]
         {
-            assert!(builder.hash().unwrap() == Oid::from_str(EMPTY_PACKFILE_OID).unwrap());
+            let oid = crate::Oid::from_str(EMPTY_PACKFILE_OID).unwrap();
+            assert_eq!(builder.hash().unwrap(), oid);
         }
-        assert!(builder.name().unwrap() == EMPTY_PACKFILE_OID);
+        assert_eq!(builder.name().unwrap(), EMPTY_PACKFILE_OID);
+    }
+
+    #[test]
+    #[cfg(feature = "unstable-sha256")]
+    #[ignore = "git_packbuilder_write hasnt yet supported sha256; see https://github.com/libgit2/libgit2/pull/7179"]
+    fn smoke_write_object_format() {
+        // SHA256 hash of a packfile constructed without any objects in it
+        const EMPTY_PACKFILE_OID_SHA256: &str =
+            "7ed890d8a45760f3eecf73045b1d1047085af4776dc683d78eac82203df1993f";
+
+        let (_td, repo) = crate::test::repo_init_sha256();
+        let mut builder = t!(repo.packbuilder());
+        t!(builder.write(repo.path(), 0));
+        assert_eq!(builder.name().unwrap(), EMPTY_PACKFILE_OID_SHA256);
     }
 
     #[test]
@@ -364,6 +408,19 @@ mod tests {
         assert_eq!(&*buf, &*empty_pack_header());
     }
 
+    #[test]
+    #[cfg(feature = "unstable-sha256")]
+    fn smoke_foreach_sha256() {
+        let (_td, repo) = crate::test::repo_init_sha256();
+        let mut builder = t!(repo.packbuilder());
+        let mut buf = Vec::<u8>::new();
+        t!(builder.foreach(|bytes| {
+            buf.extend(bytes);
+            true
+        }));
+        assert_eq!(&*buf, &*empty_pack_header_sha256());
+    }
+
     #[test]
     fn insert_write_buf() {
         let (_td, repo) = crate::test::repo_init();
@@ -377,6 +434,20 @@ mod tests {
         assert_eq!(&buf[0..12], &*pack_header(1));
     }
 
+    #[test]
+    #[cfg(feature = "unstable-sha256")]
+    fn insert_write_buf_sha256() {
+        let (_td, repo) = crate::test::repo_init_sha256();
+        let mut builder = t!(repo.packbuilder());
+        let mut buf = Buf::new();
+        let (commit, _tree) = crate::test::commit(&repo);
+        t!(builder.insert_object(commit, None));
+        assert_eq!(builder.object_count(), 1);
+        t!(builder.write_buf(&mut buf));
+        // Just check that the correct number of objects are written
+        assert_eq!(&buf[0..12], &*pack_header(1));
+    }
+
     #[test]
     fn insert_tree_write_buf() {
         let (_td, repo) = crate::test::repo_init();
@@ -391,6 +462,21 @@ mod tests {
         assert_eq!(&buf[0..12], &*pack_header(2));
     }
 
+    #[test]
+    #[cfg(feature = "unstable-sha256")]
+    fn insert_tree_write_buf_sha256() {
+        let (_td, repo) = crate::test::repo_init_sha256();
+        let mut builder = t!(repo.packbuilder());
+        let mut buf = Buf::new();
+        let (_commit, tree) = crate::test::commit(&repo);
+        // will insert the tree itself and the blob, 2 objects
+        t!(builder.insert_tree(tree));
+        assert_eq!(builder.object_count(), 2);
+        t!(builder.write_buf(&mut buf));
+        // Just check that the correct number of objects are written
+        assert_eq!(&buf[0..12], &*pack_header(2));
+    }
+
     #[test]
     fn insert_commit_write_buf() {
         let (_td, repo) = crate::test::repo_init();
@@ -405,6 +491,21 @@ mod tests {
         assert_eq!(&buf[0..12], &*pack_header(3));
     }
 
+    #[test]
+    #[cfg(feature = "unstable-sha256")]
+    fn insert_commit_write_buf_sha256() {
+        let (_td, repo) = crate::test::repo_init_sha256();
+        let mut builder = t!(repo.packbuilder());
+        let mut buf = Buf::new();
+        let (commit, _tree) = crate::test::commit(&repo);
+        // will insert the commit, its tree and the blob, 3 objects
+        t!(builder.insert_commit(commit));
+        assert_eq!(builder.object_count(), 3);
+        t!(builder.write_buf(&mut buf));
+        // Just check that the correct number of objects are written
+        assert_eq!(&buf[0..12], &*pack_header(3));
+    }
+
     #[test]
     fn insert_write() {
         let (_td, repo) = crate::test::repo_init();
@@ -416,6 +517,19 @@ mod tests {
         t!(repo.find_commit(commit));
     }
 
+    #[test]
+    #[cfg(feature = "unstable-sha256")]
+    #[ignore = "git_packbuilder_write hasnt yet supported sha256; see https://github.com/libgit2/libgit2/pull/7179"]
+    fn insert_write_sha256() {
+        let (_td, repo) = crate::test::repo_init_sha256();
+        let mut builder = t!(repo.packbuilder());
+        let (commit, _tree) = crate::test::commit(&repo);
+        t!(builder.insert_object(commit, None));
+        assert_eq!(builder.object_count(), 1);
+        t!(builder.write(repo.path(), 0));
+        t!(repo.find_commit(commit));
+    }
+
     #[test]
     fn insert_tree_write() {
         let (_td, repo) = crate::test::repo_init();
@@ -428,6 +542,20 @@ mod tests {
         t!(repo.find_tree(tree));
     }
 
+    #[test]
+    #[cfg(feature = "unstable-sha256")]
+    #[ignore = "git_packbuilder_write hasnt yet supported sha256; see https://github.com/libgit2/libgit2/pull/7179"]
+    fn insert_tree_write_sha256() {
+        let (_td, repo) = crate::test::repo_init_sha256();
+        let mut builder = t!(repo.packbuilder());
+        let (_commit, tree) = crate::test::commit(&repo);
+        // will insert the tree itself and the blob, 2 objects
+        t!(builder.insert_tree(tree));
+        assert_eq!(builder.object_count(), 2);
+        t!(builder.write(repo.path(), 0));
+        t!(repo.find_tree(tree));
+    }
+
     #[test]
     fn insert_commit_write() {
         let (_td, repo) = crate::test::repo_init();
@@ -440,6 +568,20 @@ mod tests {
         t!(repo.find_commit(commit));
     }
 
+    #[test]
+    #[cfg(feature = "unstable-sha256")]
+    #[ignore = "git_packbuilder_write hasnt yet supported sha256; see https://github.com/libgit2/libgit2/pull/7179"]
+    fn insert_commit_write_sha256() {
+        let (_td, repo) = crate::test::repo_init_sha256();
+        let mut builder = t!(repo.packbuilder());
+        let (commit, _tree) = crate::test::commit(&repo);
+        // will insert the commit, its tree and the blob, 3 objects
+        t!(builder.insert_commit(commit));
+        assert_eq!(builder.object_count(), 3);
+        t!(builder.write(repo.path(), 0));
+        t!(repo.find_commit(commit));
+    }
+
     #[test]
     fn progress_callback() {
         let mut progress_called = false;
diff --git a/src/remote.rs b/src/remote.rs
index 0c13a53fcf..53924b686e 100644
--- a/src/remote.rs
+++ b/src/remote.rs
@@ -1,4 +1,3 @@
-use raw::git_strarray;
 use std::iter::FusedIterator;
 use std::marker;
 use std::mem;
@@ -9,9 +8,19 @@ use std::slice;
 use std::str;
 use std::{ffi::CString, os::raw::c_char};
 
+use crate::call;
+use crate::raw;
+use crate::raw::git_strarray;
 use crate::string_array::StringArray;
 use crate::util::Binding;
-use crate::{call, raw, Buf, Direction, Error, FetchPrune, Oid, ProxyOptions, Refspec};
+use crate::Buf;
+use crate::Direction;
+use crate::Error;
+use crate::FetchPrune;
+use crate::ObjectFormat;
+use crate::Oid;
+use crate::ProxyOptions;
+use crate::Refspec;
 use crate::{AutotagOption, Progress, RemoteCallbacks, RemoteUpdateFlags, Repository};
 
 /// A structure representing a [remote][1] of a git repository.
@@ -178,6 +187,27 @@ impl<'repo> Remote<'repo> {
         }
     }
 
+    /// Get the remote's object ID format (hash algorithm).
+    ///
+    /// The remote (or more exactly its transport) must have connected to the
+    /// remote repository. The format is available as soon as the connection to
+    /// the remote is initiated and it remains available after disconnecting.
+    pub fn object_format(&self) -> Result<ObjectFormat, Error> {
+        let mut oid_type = raw::GIT_OID_SHA1;
+        unsafe {
+            try_call!(raw::git_remote_oid_type(&mut oid_type, self.raw));
+        }
+        #[cfg(not(feature = "unstable-sha256"))]
+        {
+            let _ = oid_type;
+            Ok(ObjectFormat::Sha1)
+        }
+        #[cfg(feature = "unstable-sha256")]
+        {
+            Ok(unsafe { Binding::from_raw(oid_type) })
+        }
+    }
+
     /// Open a connection to a remote.
     pub fn connect(&mut self, dir: Direction) -> Result<(), Error> {
         // TODO: can callbacks be exposed safely?
@@ -795,7 +825,7 @@ impl RemoteRedirect {
 #[cfg(test)]
 mod tests {
     use crate::{AutotagOption, PushOptions, RemoteUpdateFlags};
-    use crate::{Direction, FetchOptions, Remote, RemoteCallbacks, Repository};
+    use crate::{Direction, FetchOptions, ObjectFormat, Remote, RemoteCallbacks, Repository};
     use std::cell::Cell;
     use tempfile::TempDir;
 
@@ -865,6 +895,7 @@ mod tests {
 
         origin.connect(Direction::Fetch).unwrap();
         assert!(origin.connected());
+        assert_eq!(origin.object_format().unwrap(), ObjectFormat::Sha1);
         origin.download(&[] as &[&str], None).unwrap();
         origin.disconnect().unwrap();
 
diff --git a/src/repo.rs b/src/repo.rs
index b23341eb2b..e51d8e80a5 100644
--- a/src/repo.rs
+++ b/src/repo.rs
@@ -124,6 +124,8 @@ pub struct RepositoryInitOptions {
     template_path: Option<CString>,
     initial_head: Option<CString>,
     origin_url: Option<CString>,
+    #[cfg(feature = "unstable-sha256")]
+    oid_type: Option<raw::git_oid_t>,
 }
 
 impl Repository {
@@ -1437,7 +1439,13 @@ impl Repository {
             try_call!(raw::git_commit_lookup_prefix(
                 &mut raw,
                 self.raw(),
-                Oid::from_str(prefix_hash)?.raw(),
+                {
+                    #[cfg(not(feature = "unstable-sha256"))]
+                    let oid = Oid::from_str(prefix_hash)?;
+                    #[cfg(feature = "unstable-sha256")]
+                    let oid = Oid::from_str(prefix_hash, self.object_format())?;
+                    oid.raw()
+                },
                 prefix_hash.len()
             ));
             Ok(Binding::from_raw(raw))
@@ -1482,7 +1490,13 @@ impl Repository {
             try_call!(raw::git_object_lookup_prefix(
                 &mut raw,
                 self.raw(),
-                Oid::from_str(prefix_hash)?.raw(),
+                {
+                    #[cfg(not(feature = "unstable-sha256"))]
+                    let oid = Oid::from_str(prefix_hash)?;
+                    #[cfg(feature = "unstable-sha256")]
+                    let oid = Oid::from_str(prefix_hash, self.object_format())?;
+                    oid.raw()
+                },
                 prefix_hash.len(),
                 kind
             ));
@@ -1993,7 +2007,13 @@ impl Repository {
             try_call!(raw::git_tag_lookup_prefix(
                 &mut raw,
                 self.raw,
-                Oid::from_str(prefix_hash)?.raw(),
+                {
+                    #[cfg(not(feature = "unstable-sha256"))]
+                    let oid = Oid::from_str(prefix_hash)?;
+                    #[cfg(feature = "unstable-sha256")]
+                    let oid = Oid::from_str(prefix_hash, self.object_format())?;
+                    oid.raw()
+                },
                 prefix_hash.len()
             ));
             Ok(Binding::from_raw(raw))
@@ -3389,6 +3409,8 @@ impl RepositoryInitOptions {
             template_path: None,
             initial_head: None,
             origin_url: None,
+            #[cfg(feature = "unstable-sha256")]
+            oid_type: None,
         }
     }
 
@@ -3407,15 +3429,6 @@ impl RepositoryInitOptions {
         self.flag(raw::GIT_REPOSITORY_INIT_NO_REINIT, enabled)
     }
 
-    /// Normally a '/.git/' will be appended to the repo path for non-bare repos
-    /// (if it is not already there), but passing this flag prevents that
-    /// behavior.
-    ///
-    /// Defaults to false.
-    pub fn no_dotgit_dir(&mut self, enabled: bool) -> &mut RepositoryInitOptions {
-        self.flag(raw::GIT_REPOSITORY_INIT_NO_DOTGIT_DIR, enabled)
-    }
-
     /// Make the repo path (and workdir path) as needed. The ".git" directory
     /// will always be created regardless of this flag.
     ///
@@ -3449,6 +3462,15 @@ impl RepositoryInitOptions {
         self.flag(raw::GIT_REPOSITORY_INIT_EXTERNAL_TEMPLATE, enabled)
     }
 
+    /// If set, the gitlink created for a separate git directory will use
+    /// a relative path for the gitdir. This is useful for keeping a portable
+    /// repository.
+    ///
+    /// Defaults to false.
+    pub fn relative_gitlink(&mut self, enabled: bool) -> &mut RepositoryInitOptions {
+        self.flag(raw::GIT_REPOSITORY_INIT_RELATIVE_GITLINK, enabled)
+    }
+
     fn flag(
         &mut self,
         flag: raw::git_repository_init_flag_t,
@@ -3508,6 +3530,17 @@ impl RepositoryInitOptions {
         self
     }
 
+    /// Set the object format (hash algorithm) for the repository.
+    ///
+    /// The default is [`ObjectFormat::Sha1`].
+    /// Setting this to [`ObjectFormat::Sha256`]
+    /// will create a repository that uses SHA256 object IDs.
+    #[cfg(feature = "unstable-sha256")]
+    pub fn object_format(&mut self, format: ObjectFormat) -> &mut RepositoryInitOptions {
+        self.oid_type = Some(format.raw());
+        self
+    }
+
     /// Creates a set of raw init options to be used with
     /// `git_repository_init_ext`.
     ///
@@ -3529,6 +3562,10 @@ impl RepositoryInitOptions {
         opts.template_path = crate::call::convert(&self.template_path);
         opts.initial_head = crate::call::convert(&self.initial_head);
         opts.origin_url = crate::call::convert(&self.origin_url);
+        #[cfg(feature = "unstable-sha256")]
+        if let Some(oid_type) = self.oid_type {
+            opts.oid_type = oid_type;
+        }
         opts
     }
 }
@@ -3537,6 +3574,8 @@ impl RepositoryInitOptions {
 mod tests {
     use crate::build::CheckoutBuilder;
     use crate::ObjectFormat;
+    #[cfg(feature = "unstable-sha256")]
+    use crate::RepositoryInitOptions;
     use crate::{CherrypickOptions, MergeFileOptions};
     use crate::{
         ObjectType, Oid, Repository, ResetType, Signature, SubmoduleIgnore, SubmoduleUpdate,
@@ -3563,6 +3602,28 @@ mod tests {
         assert_eq!(oid.to_string().len(), raw::GIT_OID_SHA1_HEXSIZE);
     }
 
+    #[test]
+    #[cfg(feature = "unstable-sha256")]
+    fn smoke_init_sha256() {
+        let td = TempDir::new().unwrap();
+        let path = td.path();
+
+        let mut opts = RepositoryInitOptions::new();
+        opts.object_format(ObjectFormat::Sha256);
+
+        let repo = Repository::init_opts(path, &opts).unwrap();
+        assert!(!repo.is_bare());
+        assert_eq!(repo.object_format(), ObjectFormat::Sha256);
+
+        let oid = repo.blob(b"test").unwrap();
+        assert_eq!(oid.as_bytes().len(), raw::GIT_OID_MAX_SIZE);
+        assert_eq!(oid.to_string().len(), raw::GIT_OID_SHA256_HEXSIZE);
+
+        let config = repo.config().unwrap();
+        let format = config.get_string("extensions.objectformat").unwrap();
+        assert_eq!(format, "sha256");
+    }
+
     #[test]
     fn smoke_init_bare() {
         let td = TempDir::new().unwrap();
@@ -3574,6 +3635,22 @@ mod tests {
         assert_eq!(repo.object_format(), ObjectFormat::Sha1);
     }
 
+    #[test]
+    #[cfg(feature = "unstable-sha256")]
+    fn smoke_init_bare_sha256() {
+        let td = TempDir::new().unwrap();
+        let path = td.path();
+
+        let mut opts = RepositoryInitOptions::new();
+        opts.object_format(ObjectFormat::Sha256);
+        opts.bare(true);
+
+        let repo = Repository::init_opts(path, &opts).unwrap();
+        assert!(repo.is_bare());
+        assert!(repo.namespace().is_none());
+        assert_eq!(repo.object_format(), ObjectFormat::Sha256);
+    }
+
     #[test]
     fn smoke_open() {
         let td = TempDir::new().unwrap();
@@ -3594,6 +3671,35 @@ mod tests {
         assert_eq!(oid.to_string().len(), raw::GIT_OID_SHA1_HEXSIZE);
     }
 
+    #[test]
+    #[cfg(feature = "unstable-sha256")]
+    fn smoke_open_sha256() {
+        let td = TempDir::new().unwrap();
+        let path = td.path();
+
+        let mut opts = RepositoryInitOptions::new();
+        opts.object_format(ObjectFormat::Sha256);
+        Repository::init_opts(path, &opts).unwrap();
+
+        let repo = Repository::open(path).unwrap();
+        assert_eq!(repo.object_format(), ObjectFormat::Sha256);
+        assert!(!repo.is_bare());
+        assert!(repo.is_empty().unwrap());
+        assert_eq!(
+            crate::test::realpath(&repo.path()).unwrap(),
+            crate::test::realpath(&td.path().join(".git/")).unwrap()
+        );
+        assert_eq!(repo.state(), crate::RepositoryState::Clean);
+
+        let oid = repo.blob(b"test").unwrap();
+        assert_eq!(oid.as_bytes().len(), raw::GIT_OID_MAX_SIZE);
+        assert_eq!(oid.to_string().len(), raw::GIT_OID_SHA256_HEXSIZE);
+
+        let config = repo.config().unwrap();
+        let format = config.get_string("extensions.objectformat").unwrap();
+        assert_eq!(format, "sha256");
+    }
+
     #[test]
     fn smoke_open_bare() {
         let td = TempDir::new().unwrap();
@@ -3608,12 +3714,43 @@ mod tests {
         );
     }
 
+    #[test]
+    #[cfg(feature = "unstable-sha256")]
+    fn smoke_open_bare_sha256() {
+        let td = TempDir::new().unwrap();
+        let path = td.path();
+
+        let mut opts = RepositoryInitOptions::new();
+        opts.object_format(ObjectFormat::Sha256);
+        opts.bare(true);
+
+        Repository::init_opts(path, &opts).unwrap();
+
+        let repo = Repository::open(path).unwrap();
+        assert!(repo.is_bare());
+        assert_eq!(
+            crate::test::realpath(&repo.path()).unwrap(),
+            crate::test::realpath(&td.path().join("")).unwrap()
+        );
+    }
+
     #[test]
     fn smoke_checkout() {
         let (_td, repo) = crate::test::repo_init();
         repo.checkout_head(None).unwrap();
     }
 
+    #[test]
+    #[cfg(feature = "unstable-sha256")]
+    fn smoke_checkout_sha256() {
+        let (_td, repo) = crate::test::repo_init_sha256();
+        repo.checkout_head(None).unwrap();
+
+        let config = repo.config().unwrap();
+        let format = config.get_string("extensions.objectformat").unwrap();
+        assert_eq!(format, "sha256");
+    }
+
     #[test]
     fn smoke_revparse() {
         let (_td, repo) = crate::test::repo_init();
@@ -3631,6 +3768,28 @@ mod tests {
         t!(repo.reset(&obj, ResetType::Soft, Some(&mut opts)));
     }
 
+    #[test]
+    #[cfg(feature = "unstable-sha256")]
+    fn smoke_revparse_sha256() {
+        let (_td, repo) = crate::test::repo_init_sha256();
+        let rev = repo.revparse("HEAD").unwrap();
+        assert!(rev.to().is_none());
+        let from = rev.from().unwrap();
+        assert!(rev.from().is_some());
+
+        assert_eq!(repo.revparse_single("HEAD").unwrap().id(), from.id());
+        let obj = repo.find_object(from.id(), None).unwrap().clone();
+        obj.peel(ObjectType::Any).unwrap();
+        obj.short_id().unwrap();
+        repo.reset(&obj, ResetType::Hard, None).unwrap();
+        let mut opts = CheckoutBuilder::new();
+        t!(repo.reset(&obj, ResetType::Soft, Some(&mut opts)));
+
+        let config = repo.config().unwrap();
+        let format = config.get_string("extensions.objectformat").unwrap();
+        assert_eq!(format, "sha256");
+    }
+
     #[test]
     fn makes_dirs() {
         let td = TempDir::new().unwrap();
@@ -3809,7 +3968,11 @@ mod tests {
     fn smoke_set_head_detached() {
         let (_td, repo) = crate::test::repo_init();
 
-        let void_oid = Oid::from_bytes(b"00000000000000000000").unwrap();
+        let void_oid = match repo.object_format() {
+            ObjectFormat::Sha1 => Oid::from_bytes(&[0; raw::GIT_OID_SHA1_SIZE]).unwrap(),
+            #[cfg(feature = "unstable-sha256")]
+            ObjectFormat::Sha256 => Oid::from_bytes(&[0; raw::GIT_OID_SHA256_SIZE]).unwrap(),
+        };
         assert!(repo.set_head_detached(void_oid).is_err());
 
         let main_oid = repo.revparse_single("main").unwrap().id();
diff --git a/src/test.rs b/src/test.rs
index 57a590f519..b9ec23fb93 100644
--- a/src/test.rs
+++ b/src/test.rs
@@ -37,6 +37,28 @@ pub fn repo_init() -> (TempDir, Repository) {
     (td, repo)
 }
 
+#[cfg(feature = "unstable-sha256")]
+pub fn repo_init_sha256() -> (TempDir, Repository) {
+    let td = TempDir::new().unwrap();
+    let mut opts = RepositoryInitOptions::new();
+    opts.initial_head("main");
+    opts.object_format(crate::ObjectFormat::Sha256);
+    let repo = Repository::init_opts(td.path(), &opts).unwrap();
+    {
+        let mut config = repo.config().unwrap();
+        config.set_str("user.name", "name").unwrap();
+        config.set_str("user.email", "email").unwrap();
+        let mut index = repo.index().unwrap();
+        let id = index.write_tree().unwrap();
+
+        let tree = repo.find_tree(id).unwrap();
+        let sig = repo.signature().unwrap();
+        repo.commit(Some("HEAD"), &sig, &sig, "initial\n\nbody", &tree, &[])
+            .unwrap();
+    }
+    (td, repo)
+}
+
 pub fn commit(repo: &Repository) -> (Oid, Oid) {
     let mut index = t!(repo.index());
     let root = repo.path().parent().unwrap();
diff --git a/src/transaction.rs b/src/transaction.rs
index 4f661f1d48..84caeadee4 100644
--- a/src/transaction.rs
+++ b/src/transaction.rs
@@ -162,7 +162,8 @@ mod tests {
         t!(tx.lock_ref("refs/heads/main"));
         t!(tx.lock_ref("refs/heads/next"));
 
-        t!(tx.set_target("refs/heads/main", Oid::zero(), None, "set main to zero"));
+        let oid = Oid::from_bytes(&[1u8; 20]).unwrap();
+        t!(tx.set_target("refs/heads/main", oid, None, "set main to all ones"));
         t!(tx.set_symbolic_target(
             "refs/heads/next",
             "refs/heads/main",
@@ -172,7 +173,38 @@ mod tests {
 
         t!(tx.commit());
 
-        assert_eq!(repo.refname_to_id("refs/heads/main").unwrap(), Oid::zero());
+        assert_eq!(repo.refname_to_id("refs/heads/main").unwrap(), oid);
+        assert_eq!(
+            repo.find_reference("refs/heads/next")
+                .unwrap()
+                .symbolic_target()
+                .unwrap(),
+            "refs/heads/main"
+        );
+    }
+
+    #[test]
+    #[cfg(feature = "unstable-sha256")]
+    fn smoke_sha256() {
+        let (_td, repo) = crate::test::repo_init_sha256();
+
+        let mut tx = t!(repo.transaction());
+
+        t!(tx.lock_ref("refs/heads/main"));
+        t!(tx.lock_ref("refs/heads/next"));
+
+        let oid = Oid::from_bytes(&[1u8; 32]).unwrap();
+        t!(tx.set_target("refs/heads/main", oid, None, "set main to all ones"));
+        t!(tx.set_symbolic_target(
+            "refs/heads/next",
+            "refs/heads/main",
+            None,
+            "set next to main",
+        ));
+
+        t!(tx.commit());
+
+        assert_eq!(repo.refname_to_id("refs/heads/main").unwrap(), oid);
         assert_eq!(
             repo.find_reference("refs/heads/next")
                 .unwrap()
diff --git a/systest/build.rs b/systest/build.rs
index bb8a32e753..78c4138e56 100644
--- a/systest/build.rs
+++ b/systest/build.rs
@@ -14,10 +14,17 @@ fn main() {
         cfg.define("GIT_EXPERIMENTAL_SHA256", Some("1"));
     }
 
+    // Ensure mode_t exists for MSVC when compiling public headers.
+    // This header is a no-op on non-MSVC toolchains.
+    let manifest_dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR").unwrap());
+    cfg.include(manifest_dir.join("include"))
+        .header("git2-systest-win32.h");
+
     cfg.header("git2.h")
         .header("git2/sys/errors.h")
         .header("git2/sys/transport.h")
         .header("git2/sys/refs.h")
+        .header("git2/refdb.h")
         .header("git2/sys/refdb_backend.h")
         .header("git2/sys/odb_backend.h")
         .header("git2/sys/mempack.h")
diff --git a/systest/include/git2-systest-win32.h b/systest/include/git2-systest-win32.h
new file mode 100644
index 0000000000..393ceb2c72
--- /dev/null
+++ b/systest/include/git2-systest-win32.h
@@ -0,0 +1,12 @@
+/* Mirrors libgit2's MSVC compatibility typedef.
+ * Reference: libgit2/src/util/win32/msvc-compat.h
+ */
+#ifndef GIT2_SYS_TEST_WIN32_COMPAT_H
+#define GIT2_SYS_TEST_WIN32_COMPAT_H
+
+#if defined(_MSC_VER) && !defined(_MODE_T_DEFINED)
+typedef unsigned short mode_t;
+#define _MODE_T_DEFINED
+#endif
+
+#endif
diff --git a/tests/add_extensions.rs b/tests/add_extensions.rs
index d49c33cf79..205dcf2397 100644
--- a/tests/add_extensions.rs
+++ b/tests/add_extensions.rs
@@ -21,6 +21,8 @@ fn test_add_extensions() -> Result<(), Error> {
             Some("objectformat"),
             // The preciousobjects extension was added in 1.9
             Some("preciousobjects"),
+            // The refstorage extension was added in 1.9
+            Some("refstorage"),
             // The worktreeconfig extension was added in 1.8
             Some("worktreeconfig")
         ]
diff --git a/tests/get_extensions.rs b/tests/get_extensions.rs
index 2ac362d0ba..1e2d5722ec 100644
--- a/tests/get_extensions.rs
+++ b/tests/get_extensions.rs
@@ -16,6 +16,8 @@ fn test_get_extensions() -> Result<(), Error> {
             Some("objectformat"),
             // The preciousobjects extension was added in 1.9
             Some("preciousobjects"),
+            // The refstorage extension was added in 1.9
+            Some("refstorage"),
             // The worktreeconfig extension was added in 1.8
             Some("worktreeconfig")
         ]
diff --git a/tests/remove_extensions.rs b/tests/remove_extensions.rs
index 3e54b427b7..8e74c585ac 100644
--- a/tests/remove_extensions.rs
+++ b/tests/remove_extensions.rs
@@ -12,6 +12,7 @@ fn test_remove_extensions() -> Result<(), Error> {
             "!noop",
             "!objectformat",
             "!preciousobjects",
+            "!refstorage",
             "!worktreeconfig",
             "other",
         ])?;