git rebase without changing commit timestamps

Would it make sense to perform git rebase while preserving the commit timestamps?

I believe a consequence would be that the new branch will not necessarily have commit dates chronologically. Is that theoretically possible at all? (e.g. using plumbing commands; just curious here)

  • git and libgit : unable to create file (No such file or directory)
  • Automatically update text in many documents in eclipse or any editor
  • Change branch of GIT GUI
  • Rebase branch after removing file from history
  • Git: commit and automatically add all untracked files
  • I need to get a list of branches of a git repo without having cloned the repo on my local machine
  • If it is theoretically possible, then is it possible in practice with rebase, not to change the timestamps?

    For example, assume I have the following tree:

    master <jun 2010>
      :     oldbranch <feb 1984>
      :     /
    oldcommit <jan 1984>

    Now, if I rebase oldbranch on master, the date of the commit changes from feb 1984 to jun 2010. Is it possible to change that behaviour so that the commit timestamp is not changed? In the end I would thus obtain:

          oldbranch <feb 1984>
     master <jun 2010>

    Would that make sense at all? Is it even allowed in git to have a history where an old commit has a more recent commit as a parent?

  • Is there a diff tool launcher for Git that lets you interactively select from a file listing?
  • Git Rebase: Merge branch before last commit
  • How do i enable syntax highlighting and syntax indentation in msysgit vim?
  • How can I compare my local forked repository with changes that may have been made to the original?
  • Use of git rebase in publicy feature branchs
  • Git ignore file locally and always merge theirs
  • 4 Solutions collect form web for “git rebase without changing commit timestamps”

    If you’ve already screwed up the commit dates (perhaps with a rebase) and want to reset them to their corresponding author dates, you can run:

    git filter-branch --env-filter 'GIT_COMMITTER_DATE=$GIT_AUTHOR_DATE; export GIT_COMMITTER_DATE'

    Update June 2014: David Fraser mentions in the comments a solution also detailed in “Change timestamps while rebasing git branch”, using the option --committer-date-is-author-date (introduced initially in Jan. 2009 in commit 3f01ad6

    Note that the --committer-date-is-author-date option seems to leave the author timestamp, and set the committer timestamp to be the same as the original author timestamp, which is what the OP Olivier Verdier wanted.

    I found the last commit with the correct date and did:

    git rebase --committer-date-is-author-date SHA

    See git am:


    By default the command records the date from the e-mail message as the commit author date, and uses the time of commit creation as the committer date.
    This allows the user to lie about the committer date by using the same value as the author date.

    (Original answer, June 2012)

    You could try, for a non-interactive rebase

    git rebase --ignore-date

    (from this SO answer)

    This is passed to git am, which mentions:


    By default the command records the date from the e-mail message as the commit author date, and uses the time of commit creation as the committer date.
    This allows the user to lie about the author date by using the same value as the committer date.

    For git rebase, this option is “Incompatible with the –interactive option.”

    Since you can change at will the timestamp of old commit date (with git filter-branch), I suppose you can organize your Git history with whatever commit date order you want/need, even set it to the future!.

    As Olivier mentions in his question, the author date is never changed by a rebase;
    From the Pro Git Book:

    • The author is the person who originally wrote the work,
    • whereas the committer is the person who last applied the work.

    So, if you send in a patch to a project and one of the core members applies the patch, both of you get credit.

    To be extra clear, in this instance, as Olivier comments:

    the --ignore-date does the opposite of what I was trying to achieve!
    Namely, it erases the author’s timestamp and replace them with the commits timestamps!
    So the right answer to my question is:
    Do not do anything, since git rebase does actually not change authors’ timestamps by default.

    A crucial question of Von C helped me understand what is going on: when your rebase, the committer’s timestamp changes, but not the author’s timestamp, which suddenly all makes sense. So my question was actually not precise enough.

    The answer is that rebase actually doesn’t change the author’s timestamps (you don’t need to do anything for that), which suits me perfectly.

    By default, git rebase will set the committer’s timestamp to the time when the
    new commit is created, but keep the author’s timestamp intact. Most of time,
    this is the desired behavior, but at some scenarios, we dot not wish to change
    the commiter’s timestamp either. How can we accomplish that? Well, here is the
    trick I usually do.

    First, make sure each of the commits you are about to rebase has a unique
    commit message(This is where is trick needs improvements, currently it suits my
    needs though).

    Before the rebase, record the commiter’s timestamp and commit message of all
    the commits which will be rebased to a file.

    #NOTE: BASE is the commit where your rebase begins
    git log --pretty='%ct %s' BASE..HEAD > hashlog

    Then,let the actual rebase take place.

    Finally, we replace the current committer’s timestamp with the one recorded in
    the file if the commit message is the same by using git filter-branch.

     git filter-branch --env-filter '__date=$(__log=$(git log -1 --pretty="%s" $GIT_COMMIT); grep -m 1 "$__log" ../../hashlog | cut -d" " -f1); test -n "$__date" && export GIT_COMMITTER_DATE=$__date || cat' ")'

    If something goes wrong, just checkout git reflog or all the refs/original/ refs.

    Furthormore, you can do the similar thing to the author’s timestamp.

    For example, if the author’s timestamp of some commits are out of order, and
    without rearrange these commits, we just want the author’s timestamp to show in
    order, then the following commands will help.

    git log --pretty='%at %s' COMMIT1..COMMIT2 > hashlog
    join -1 1 -2 1 <(cat hashlog | cut -f 1 | sort -nr | awk '{ print NR" "$1 }') <(cat hashlog | awk '{ print NR" "$0 }') | cut -d" " -f2,4- > hashlog_
    mv hashlog_ hashlog
    git filter-branch --env-filter '__date=$(__log=$(git log -1 --pretty="%s" $GIT_COMMIT); grep -m 1 "$__log" ../../hashlog | cut -d" " -f1); test -n "$__date" && export GIT_AUTHOR_DATE=$__date || cat' ")'
    Git Baby is a git and github fan, let's start git clone.