diff --git a/LibGit2Sharp.Tests/CommitFixture.cs b/LibGit2Sharp.Tests/CommitFixture.cs
index 4b4db8ec7..1d302023c 100644
--- a/LibGit2Sharp.Tests/CommitFixture.cs
+++ b/LibGit2Sharp.Tests/CommitFixture.cs
@@ -614,7 +614,8 @@ public void CanCommitALittleBit()
                 Assert.Null(repo.Head[relativeFilepath]);
 
                 var author = DummySignature;
-                Commit commit = repo.Commit("Initial egotistic commit", author, author);
+                const string commitMessage = "Initial egotistic commit";
+                Commit commit = repo.Commit(commitMessage, author, author);
 
                 AssertBlobContent(repo.Head[relativeFilepath], "nulltoken\n");
                 AssertBlobContent(commit[relativeFilepath], "nulltoken\n");
@@ -622,6 +623,14 @@ public void CanCommitALittleBit()
                 Assert.Equal(0, commit.Parents.Count());
                 Assert.False(repo.Info.IsHeadOrphaned);
 
+                // Assert a reflog entry is created
+                Assert.Equal(1, repo.Refs.Log("HEAD").Count());
+                var reflogEntry = repo.Refs.Log("HEAD").First();
+                Assert.Equal(author, reflogEntry.Commiter);
+                Assert.Equal(commit.Id, reflogEntry.To);
+                Assert.Equal(ObjectId.Zero, reflogEntry.From);
+                Assert.Equal(string.Format("commit (initial): {0}", commitMessage), reflogEntry.Message);
+
                 File.WriteAllText(filePath, "nulltoken commits!\n");
                 repo.Index.Stage(relativeFilepath);
 
@@ -634,6 +643,10 @@ public void CanCommitALittleBit()
                 Assert.Equal(1, commit2.Parents.Count());
                 Assert.Equal(commit.Id, commit2.Parents.First().Id);
 
+                // Assert the reflog is shifted
+                Assert.Equal(2, repo.Refs.Log("HEAD").Count());
+                Assert.Equal(reflogEntry.To, repo.Refs.Log("HEAD").First().From);
+
                 Branch firstCommitBranch = repo.CreateBranch("davidfowl-rules", commit);
                 repo.Checkout(firstCommitBranch);
 
@@ -731,10 +744,17 @@ public void CanAmendACommitWithMoreThanOneParent()
                 repo.Reset(ResetOptions.Soft, mergedCommit.Sha);
 
                 CreateAndStageANewFile(repo);
+                const string commitMessage = "I'm rewriting the history!";
 
-                Commit amendedCommit = repo.Commit("I'm rewriting the history!", DummySignature, DummySignature, true);
+                Commit amendedCommit = repo.Commit(commitMessage, DummySignature, DummySignature, true);
 
                 AssertCommitHasBeenAmended(repo, amendedCommit, mergedCommit);
+
+                // Assert a reflog entry is created
+                var reflogEntry = repo.Refs.Log("HEAD").First();
+                Assert.Equal(amendedCommit.Committer, reflogEntry.Commiter);
+                Assert.Equal(amendedCommit.Id, reflogEntry.To);
+                Assert.Equal(string.Format("commit (amend): {0}", commitMessage), reflogEntry.Message);
             }
         }
 
diff --git a/LibGit2Sharp.Tests/LibGit2Sharp.Tests.csproj b/LibGit2Sharp.Tests/LibGit2Sharp.Tests.csproj
index f2568f2cd..a6b9b20fc 100644
--- a/LibGit2Sharp.Tests/LibGit2Sharp.Tests.csproj
+++ b/LibGit2Sharp.Tests/LibGit2Sharp.Tests.csproj
@@ -61,6 +61,7 @@
     <Compile Include="CheckoutFixture.cs" />
     <Compile Include="RemoteFixture.cs" />
     <Compile Include="PushFixture.cs" />
+    <Compile Include="ReflogFixture.cs" />
     <Compile Include="StageFixture.cs" />
     <Compile Include="StashFixture.cs" />
     <Compile Include="CloneFixture.cs" />
diff --git a/LibGit2Sharp.Tests/ReferenceFixture.cs b/LibGit2Sharp.Tests/ReferenceFixture.cs
index 38a0d9b54..860cec7ca 100644
--- a/LibGit2Sharp.Tests/ReferenceFixture.cs
+++ b/LibGit2Sharp.Tests/ReferenceFixture.cs
@@ -686,6 +686,21 @@ public void CanTellIfAReferenceIsValid(string refname, bool expectedResult)
             }
         }
 
+        [Fact]
+        public void CanUpdateTheTargetOfASymbolicReferenceWithAnotherSymbolicReference()
+        {
+            SelfCleaningDirectory scd = BuildSelfCleaningDirectory();
+
+            using (var repo = Repository.Init(scd.DirectoryPath))
+            {
+                Reference symbolicRef = repo.Refs.Add("refs/heads/unit_test", "refs/heads/master");
+
+                Reference newHead = repo.Refs.UpdateTarget(repo.Refs.Head, symbolicRef);
+                Assert.IsType<SymbolicReference>(newHead);
+                Assert.Equal(symbolicRef.CanonicalName, newHead.TargetIdentifier);
+            }
+        }
+
         private static T[] SortedRefs<T>(IRepository repo, Func<Reference, T> selector)
         {
             return repo.Refs.OrderBy(r => r.CanonicalName, StringComparer.Ordinal).Select(selector).ToArray();
diff --git a/LibGit2Sharp.Tests/ReflogFixture.cs b/LibGit2Sharp.Tests/ReflogFixture.cs
new file mode 100644
index 000000000..a5f287f4c
--- /dev/null
+++ b/LibGit2Sharp.Tests/ReflogFixture.cs
@@ -0,0 +1,106 @@
+using System.IO;
+using LibGit2Sharp.Tests.TestHelpers;
+using System.Linq;
+using Xunit;
+
+namespace LibGit2Sharp.Tests
+{
+    public class ReflogFixture : BaseFixture
+    {
+        [Fact]
+        public void CanReadReflog()
+        {
+            const int expectedReflogEntriesCount = 3;
+
+
+            using (var repo = new Repository(StandardTestRepoWorkingDirPath))
+            {
+                var reflog = repo.Refs.Log(repo.Refs.Head);
+
+                Assert.Equal(expectedReflogEntriesCount, reflog.Count());
+
+                // Initial commit assertions
+                Assert.Equal("timothy.clem@gmail.com", reflog.Last().Commiter.Email);
+                Assert.True(reflog.Last().Message.StartsWith("clone: from"));
+                Assert.Equal(ObjectId.Zero, reflog.Last().From);
+
+                // second commit assertions
+                Assert.Equal("4c062a6361ae6959e06292c1fa5e2822d9c96345", reflog.ElementAt(expectedReflogEntriesCount - 2).From.Sha);
+                Assert.Equal("592d3c869dbc4127fc57c189cb94f2794fa84e7e", reflog.ElementAt(expectedReflogEntriesCount - 2).To.Sha);
+            }
+        }
+
+        [Fact]
+        public void CannotReadReflogOnUnknownReference()
+        {
+            using (var repo = new Repository(StandardTestRepoWorkingDirPath))
+            {
+                Assert.Throws<InvalidSpecificationException>(() => repo.Refs.Log("toto").Count());
+            }
+        }
+
+        [Fact]
+        public void CommitShouldCreateReflogEntryOnHeadandOnTargetedDirectReference()
+        {
+            SelfCleaningDirectory scd = BuildSelfCleaningDirectory();
+
+            using (var repo = Repository.Init(scd.DirectoryPath))
+            {
+                // setup refs as HEAD => unit_test => master
+                var newRef = repo.Refs.Add("refs/heads/unit_test", "refs/heads/master");
+                Assert.NotNull(newRef);
+                repo.Refs.UpdateTarget(repo.Refs.Head, newRef);
+
+                const string relativeFilepath = "new.txt";
+                string filePath = Path.Combine(repo.Info.WorkingDirectory, relativeFilepath);
+
+                File.WriteAllText(filePath, "content\n");
+                repo.Index.Stage(relativeFilepath);
+
+                var author = DummySignature;
+                const string commitMessage = "Hope reflog behaves as it should";
+                Commit commit = repo.Commit(commitMessage, author, author);
+
+                // Assert a reflog entry is created on HEAD
+                Assert.Equal(1, repo.Refs.Log("HEAD").Count());
+                var reflogEntry = repo.Refs.Log("HEAD").First();
+                Assert.Equal(author, reflogEntry.Commiter);
+                Assert.Equal(commit.Id, reflogEntry.To);
+                Assert.Equal(ObjectId.Zero, reflogEntry.From);
+
+                // Assert the same reflog entry is created on refs/heads/master
+                Assert.Equal(1, repo.Refs.Log("refs/heads/master").Count());
+                reflogEntry = repo.Refs.Log("HEAD").First();
+                Assert.Equal(author, reflogEntry.Commiter);
+                Assert.Equal(commit.Id, reflogEntry.To);
+                Assert.Equal(ObjectId.Zero, reflogEntry.From);
+
+                // Assert no reflog entry is created on refs/heads/unit_test
+                Assert.Equal(0, repo.Refs.Log("refs/heads/unit_test").Count());
+            }
+        }
+
+        [Fact]
+        public void CommitOnUnbornReferenceShouldCreateReflogEntryWithInitialTag()
+        {
+            SelfCleaningDirectory scd = BuildSelfCleaningDirectory();
+
+            using (var repo = Repository.Init(scd.DirectoryPath))
+            {
+                const string relativeFilepath = "new.txt";
+                string filePath = Path.Combine(repo.Info.WorkingDirectory, relativeFilepath);
+
+                File.WriteAllText(filePath, "content\n");
+                repo.Index.Stage(relativeFilepath);
+
+                var author = DummySignature;
+                const string commitMessage = "First commit should be logged as initial";
+                repo.Commit(commitMessage, author, author);
+
+                // Assert the reflog entry message is correct
+                Assert.Equal(1, repo.Refs.Log("HEAD").Count());
+                Assert.Equal(string.Format("commit (initial): {0}", commitMessage), repo.Refs.Log("HEAD").First().Message);
+            }
+        }
+    }
+}
diff --git a/LibGit2Sharp/Core/Handles/ReflogEntrySafeHandle.cs b/LibGit2Sharp/Core/Handles/ReflogEntrySafeHandle.cs
new file mode 100644
index 000000000..1739ccac3
--- /dev/null
+++ b/LibGit2Sharp/Core/Handles/ReflogEntrySafeHandle.cs
@@ -0,0 +1,6 @@
+namespace LibGit2Sharp.Core.Handles
+{
+    internal class ReflogEntrySafeHandle : NotOwnedSafeHandleBase
+    {
+    }
+}
diff --git a/LibGit2Sharp/Core/Handles/ReflogSafeHandle.cs b/LibGit2Sharp/Core/Handles/ReflogSafeHandle.cs
new file mode 100644
index 000000000..a75deabea
--- /dev/null
+++ b/LibGit2Sharp/Core/Handles/ReflogSafeHandle.cs
@@ -0,0 +1,11 @@
+namespace LibGit2Sharp.Core.Handles
+{
+    internal class ReflogSafeHandle : SafeHandleBase
+    {
+        protected override bool ReleaseHandleImpl()
+        {
+            Proxy.git_reflog_free(handle);
+            return true;
+        }
+    }
+}
diff --git a/LibGit2Sharp/Core/NativeMethods.cs b/LibGit2Sharp/Core/NativeMethods.cs
index d6ffd2891..227f22e4b 100644
--- a/LibGit2Sharp/Core/NativeMethods.cs
+++ b/LibGit2Sharp/Core/NativeMethods.cs
@@ -699,6 +699,50 @@ internal static extern int git_reference_symbolic_set_target(
         [DllImport(libgit2)]
         internal static extern GitReferenceType git_reference_type(ReferenceSafeHandle reference);
 
+        [DllImport(libgit2)]
+        internal static extern void git_reflog_free(
+            IntPtr reflog);
+
+        [DllImport(libgit2)]
+        internal static extern int git_reflog_read(
+            out ReflogSafeHandle ref_out,
+            ReferenceSafeHandle reference);
+
+        [DllImport(libgit2)]
+        internal static extern UIntPtr git_reflog_entrycount
+            (ReflogSafeHandle reflog);
+
+        [DllImport(libgit2)]
+        internal static extern ReflogEntrySafeHandle git_reflog_entry_byindex(
+            ReflogSafeHandle reflog,
+            UIntPtr idx);
+
+        [DllImport(libgit2)]
+        internal static extern OidSafeHandle git_reflog_entry_id_old(
+            SafeHandle entry);
+
+        [DllImport(libgit2)]
+        internal static extern OidSafeHandle git_reflog_entry_id_new(
+            SafeHandle entry);
+
+        [DllImport(libgit2)]
+        internal static extern IntPtr git_reflog_entry_committer(
+            SafeHandle entry);
+
+        [DllImport(libgit2)]
+        internal static extern int git_reflog_append(
+            ReflogSafeHandle reflog,
+            ref GitOid id,
+            SignatureSafeHandle committer,
+            [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(Utf8Marshaler))] string msg);
+
+        [DllImport(libgit2)]
+        internal static extern int git_reflog_write(ReflogSafeHandle reflog);
+
+        [DllImport(libgit2)]
+        [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(Utf8NoCleanupMarshaler))]
+        internal static extern string git_reflog_entry_message(SafeHandle entry);
+
         [DllImport(libgit2)]
         internal static extern int git_refspec_rtransform(
             byte[] target,
diff --git a/LibGit2Sharp/Core/Proxy.cs b/LibGit2Sharp/Core/Proxy.cs
index 68226c20f..c6c2975e1 100644
--- a/LibGit2Sharp/Core/Proxy.cs
+++ b/LibGit2Sharp/Core/Proxy.cs
@@ -1267,6 +1267,73 @@ public static GitReferenceType git_reference_type(ReferenceSafeHandle reference)
 
         #endregion
 
+        #region git_reflog_
+
+        public static void git_reflog_free(IntPtr reflog)
+        {
+            NativeMethods.git_reflog_free(reflog);
+        }
+
+        public static ReflogSafeHandle git_reflog_read(ReferenceSafeHandle reference)
+        {
+            using (ThreadAffinity())
+            {
+                ReflogSafeHandle reflog_out;
+
+                int res = NativeMethods.git_reflog_read(out reflog_out, reference);
+                Ensure.ZeroResult(res);
+
+                return reflog_out;
+            }
+        }
+
+        public static int git_reflog_entrycount(ReflogSafeHandle reflog)
+        {
+            return (int)NativeMethods.git_reflog_entrycount(reflog);
+        }
+
+        public static ReflogEntrySafeHandle git_reflog_entry_byindex(ReflogSafeHandle reflog, int idx)
+        {
+            return NativeMethods.git_reflog_entry_byindex(reflog, (UIntPtr)idx);
+        }
+
+        public static ObjectId git_reflog_entry_id_old(SafeHandle entry)
+        {
+            return NativeMethods.git_reflog_entry_id_old(entry).MarshalAsObjectId();
+        }
+
+        public static ObjectId git_reflog_entry_id_new(SafeHandle entry)
+        {
+            return NativeMethods.git_reflog_entry_id_new(entry).MarshalAsObjectId();
+        }
+
+        public static Signature git_reflog_entry_committer(SafeHandle entry)
+        {
+            return new Signature(NativeMethods.git_reflog_entry_committer(entry));
+        }
+
+        public static string git_reflog_entry_message(SafeHandle entry)
+        {
+            return NativeMethods.git_reflog_entry_message(entry);
+        }
+
+        public static void git_reflog_append(ReflogSafeHandle reflog, ObjectId commit_id, Signature committer, string message)
+        {
+            using (ThreadAffinity())
+            using (SignatureSafeHandle committerHandle = committer.BuildHandle())
+            {
+                var oid = commit_id.Oid;
+
+                int res = NativeMethods.git_reflog_append(reflog, ref oid, committerHandle, message);
+                Ensure.ZeroResult(res);
+
+                res = NativeMethods.git_reflog_write(reflog);
+                Ensure.ZeroResult(res);
+            }
+        }
+
+        #endregion
+
         #region git_refspec
 
         public static string git_refspec_rtransform(GitRefSpecHandle refSpecPtr, string name)
diff --git a/LibGit2Sharp/LibGit2Sharp.csproj b/LibGit2Sharp/LibGit2Sharp.csproj
index 28fee9413..b88853e12 100644
--- a/LibGit2Sharp/LibGit2Sharp.csproj
+++ b/LibGit2Sharp/LibGit2Sharp.csproj
@@ -71,10 +71,14 @@
     <Compile Include="ConflictCollection.cs" />
     <Compile Include="Core\Handles\GitRefSpecHandle.cs" />
     <Compile Include="UnmatchedPathException.cs" />
+    <Compile Include="Core\Handles\ReflogEntrySafeHandle.cs" />
+    <Compile Include="Core\Handles\ReflogSafeHandle.cs" />
+    <Compile Include="ReflogCollection.cs" />
     <Compile Include="Core\PathCase.cs" />
     <Compile Include="MatchedPathsAggregator.cs" />
     <Compile Include="Network.cs" />
     <Compile Include="Core\GitRemoteHead.cs" />
+    <Compile Include="ReflogEntry.cs" />
     <Compile Include="Stash.cs" />
     <Compile Include="StashOptions.cs" />
     <Compile Include="OrphanedHeadException.cs" />
diff --git a/LibGit2Sharp/ReferenceCollection.cs b/LibGit2Sharp/ReferenceCollection.cs
index 3c19e02b2..43a2e4b2c 100644
--- a/LibGit2Sharp/ReferenceCollection.cs
+++ b/LibGit2Sharp/ReferenceCollection.cs
@@ -191,6 +191,11 @@ private Reference UpdateTarget<T>(Reference reference, T target, Func<ReferenceS
                     return Add("HEAD", target as DirectReference, true);
                 }
 
+                if (target is SymbolicReference)
+                {
+                    return Add("HEAD", target as SymbolicReference, true);
+                }
+
                 throw new ArgumentException(string.Format(CultureInfo.InvariantCulture,
                     "'{0}' is not a valid target type.", typeof(T)));
             }
@@ -262,5 +267,29 @@ private string DebuggerDisplay
                     "Count = {0}", this.Count());
             }
         }
+
+        /// <summary>
+        ///   Returns as a <see cref="ReflogCollection"/> the reflog of the <see cref="Reference"/> named <paramref name="canonicalName"/>
+        /// </summary>
+        /// <param name="canonicalName">The canonical name of the reference</param>
+        /// <returns>a <see cref="ReflogCollection"/>, enumerable of <see cref="ReflogEntry"/></returns>
+        public virtual ReflogCollection Log(string canonicalName)
+        {
+            Ensure.ArgumentNotNullOrEmptyString(canonicalName, "canonicalName");
+
+            return new ReflogCollection(repo, canonicalName);
+        }
+
+        /// <summary>
+        ///   Returns as a <see cref="ReflogCollection"/> the reflog of the <see cref="Reference"/> <paramref name="reference"/>
+        /// </summary>
+        /// <param name="reference">The reference</param>
+        /// <returns>a <see cref="ReflogCollection"/>, enumerable of <see cref="ReflogEntry"/></returns>
+        public virtual ReflogCollection Log(Reference reference)
+        {
+            Ensure.ArgumentNotNull(reference, "reference");
+
+            return new ReflogCollection(repo, reference.CanonicalName);
+        }
     }
 }
diff --git a/LibGit2Sharp/ReflogCollection.cs b/LibGit2Sharp/ReflogCollection.cs
new file mode 100644
index 000000000..1cd50af1b
--- /dev/null
+++ b/LibGit2Sharp/ReflogCollection.cs
@@ -0,0 +1,107 @@
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Globalization;
+using System.Linq;
+using LibGit2Sharp.Core;
+using LibGit2Sharp.Core.Handles;
+
+namespace LibGit2Sharp
+{
+    /// <summary>
+    ///   The <see cref="ReflogCollection"/> is the reflog of a given <see cref="Reference"/>, as a enumerable of <see cref = "ReflogEntry" />.
+    ///   Reflog is a mechanism to record when the tip of a <see cref="Branch"/> is updated.
+    /// </summary>
+    [DebuggerDisplay("{DebuggerDisplay,nq}")]
+    public class ReflogCollection : IEnumerable<ReflogEntry>
+    {
+        internal readonly Repository repo;
+
+        private readonly string canonicalName;
+
+        /// <summary>
+        ///   Needed for mocking purposes.
+        /// </summary>
+        protected ReflogCollection()
+        { }
+
+        /// <summary>
+        ///   Initializes a new instance of the <see cref = "ReflogCollection" /> class.
+        /// </summary>
+        /// <param name = "repo">The repo.</param>
+        /// <param name="canonicalName">the canonical name of the <see cref="Reference"/> to retrieve reflog entries on.</param>
+        internal ReflogCollection(Repository repo, string canonicalName)
+        {
+            Ensure.ArgumentNotNullOrEmptyString(canonicalName, "canonicalName");
+            Ensure.ArgumentNotNull(repo, "repo");
+
+            this.repo = repo;
+            this.canonicalName = canonicalName;
+        }
+
+        #region Implementation of IEnumerable
+
+        /// <summary>
+        ///   Returns an enumerator that iterates through the collection.
+        ///   <para>
+        ///     The enumerator returns the <see cref="ReflogEntry"/> by descending order (last reflog entry is returned first).
+        ///   </para>
+        /// </summary>
+        /// <returns>An <see cref = "IEnumerator{T}" /> object that can be used to iterate through the collection.</returns>
+        public IEnumerator<ReflogEntry> GetEnumerator()
+        {
+            var entries = new List<ReflogEntry>();
+
+            using (ReferenceSafeHandle reference = Proxy.git_reference_lookup(repo.Handle, canonicalName, true))
+            using (ReflogSafeHandle reflog = Proxy.git_reflog_read(reference))
+            {
+                var entriesCount = Proxy.git_reflog_entrycount(reflog);
+
+                for (int i = 0; i < entriesCount; i++)
+                {
+                    ReflogEntrySafeHandle handle = Proxy.git_reflog_entry_byindex(reflog, i);
+                    entries.Add(new ReflogEntry(handle));
+                }
+            }
+
+            return entries.GetEnumerator();
+        }
+
+        /// <summary>
+        ///   Returns an enumerator that iterates through the collection.
+        /// </summary>
+        /// <returns>An <see cref = "IEnumerator" /> object that can be used to iterate through the collection.</returns>
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        #endregion
+
+        private string DebuggerDisplay
+        {
+            get
+            {
+                return string.Format(CultureInfo.InvariantCulture,
+                    "Count = {0}", this.Count());
+            }
+        }
+
+        /// <summary>
+        ///   Add a new <see cref="ReflogEntry"/> to the current <see cref="ReflogCollection"/>. It will be created as first item of the collection
+        ///   The native reflog object will be saved right after inserting the entry.
+        /// </summary>
+        /// <param name="objectId">the <see cref="ObjectId"/> of the new commit the <see cref="Reference"/> will point out.</param>
+        /// <param name="committer"><see cref="Signature"/> of the author of the new commit.</param>
+        /// <param name="message">the message associated with the new <see cref="ReflogEntry"/>.</param>
+        internal virtual void Append(ObjectId objectId, Signature committer, string message)
+        {
+            using (ReferenceSafeHandle reference = Proxy.git_reference_lookup(repo.Handle, canonicalName, true))
+            using (ReflogSafeHandle reflog = Proxy.git_reflog_read(reference))
+            {
+                string prettifiedMessage = Proxy.git_message_prettify(message);
+                Proxy.git_reflog_append(reflog, objectId, committer, prettifiedMessage);
+            }
+        }
+    }
+}
diff --git a/LibGit2Sharp/ReflogEntry.cs b/LibGit2Sharp/ReflogEntry.cs
new file mode 100644
index 000000000..d9f53170f
--- /dev/null
+++ b/LibGit2Sharp/ReflogEntry.cs
@@ -0,0 +1,67 @@
+using System.Runtime.InteropServices;
+using LibGit2Sharp.Core;
+
+namespace LibGit2Sharp
+{
+    /// <summary>
+    ///   As single entry of a <see cref="ReflogCollection"/>
+    ///   a <see cref="ReflogEntry"/> describes one single update on a particular reference
+    /// </summary>
+    public class ReflogEntry
+    {
+        private readonly ObjectId _from;
+        private readonly ObjectId _to;
+        private readonly Signature _commiter;
+        private readonly string message;
+
+        /// <summary>
+        ///   Needed for mocking purposes.
+        /// </summary>
+        protected ReflogEntry()
+        { }
+
+        /// <summary>
+        ///   Initializes a new instance of the <see cref = "ReflogEntry" /> class.
+        /// </summary>
+        /// <param name="entryHandle">a <see cref="SafeHandle"/> to the reflog entry</param>
+        public ReflogEntry(SafeHandle entryHandle)
+        {
+            _from = Proxy.git_reflog_entry_id_old(entryHandle);
+            _to = Proxy.git_reflog_entry_id_new(entryHandle);
+            _commiter = Proxy.git_reflog_entry_committer(entryHandle);
+            message = Proxy.git_reflog_entry_message(entryHandle);
+        }
+
+        /// <summary>
+        ///   <see cref="ObjectId"/> targeted before the reference update described by this <see cref="ReflogEntry"/>
+        /// </summary>
+        public virtual ObjectId From
+        {
+            get { return _from; }
+        }
+
+        /// <summary>
+        ///   <see cref="ObjectId"/> targeted after the reference update described by this <see cref="ReflogEntry"/>
+        /// </summary>
+        public virtual ObjectId To
+        {
+            get { return _to; }
+        }
+
+        /// <summary>
+        ///   <see cref="Signature"/> of the commiter of this reference update
+        /// </summary>
+        public virtual Signature Commiter
+        {
+            get { return _commiter; }
+        }
+
+        /// <summary>
+        ///   the message assiocated to this reference update
+        /// </summary>
+        public virtual string Message
+        {
+            get { return message; }
+        }
+    }
+}
diff --git a/LibGit2Sharp/Repository.cs b/LibGit2Sharp/Repository.cs
index 32768a470..b6532070d 100644
--- a/LibGit2Sharp/Repository.cs
+++ b/LibGit2Sharp/Repository.cs
@@ -684,9 +684,39 @@ public Commit Commit(string message, Signature author, Signature committer, bool
 
             Proxy.git_repository_merge_cleanup(handle);
 
+            // Insert reflog entry
+            LogCommit(result, amendPreviousCommit, parents.Count() == 0);
+
             return result;
         }
 
+        private void LogCommit(Commit commit, bool amendPreviousCommit, bool isInitialCommit)
+        {
+            // Compute reflog message
+            string reflogMessage = "commit";
+            if (isInitialCommit)
+            {
+                reflogMessage += " (initial)";
+            }
+            else if(amendPreviousCommit)
+            {
+                reflogMessage += " (amend)";
+            }
+
+            reflogMessage = string.Format("{0}: {1}", reflogMessage, commit.Message);
+
+            var headRef = Refs.Head;
+
+            // in case HEAD targets a symbolic reference, log commit on the targeted direct reference
+            if(headRef is SymbolicReference)
+            {
+                Refs.Log(headRef.ResolveToDirectReference()).Append(commit.Id, commit.Committer, reflogMessage);
+            }
+
+            // Log commit on HEAD
+            Refs.Log(headRef).Append(commit.Id, commit.Committer, reflogMessage);
+        }
+
         private IEnumerable<Commit> RetrieveParentsOfTheCommitBeingCreated(bool amendPreviousCommit)
         {
             if (amendPreviousCommit)