How do I clone a subdirectory only of a Git repository?

Question

I have my Git repository which, at the root, has two sub directories:

/finisht
/static

When this was in SVN, /finisht was checked out in one place, while /static was checked out elsewhere, like so:

svn co svn+ssh://admin@domain.com/home/admin/repos/finisht/static static

Is there a way to do this with Git?

possible duplicate of [Checkout subdirectories in Git?](http://stackoverflow.com/questions/180052/checkout-subdirectories-in-git) — Joachim Breitner, Jul 04 '13 at 08:43
For a 2014's user, what the `git clone` simplest command?? I used [this **simple answer**](http://stackoverflow.com/a/2466755/287948). If there are something more simple, please comment — Peter Krauss, Nov 01 '14 at 12:00
For those trying to clone the contents of the repository (not creating the root folder), this is a very easy solution: http://stackoverflow.com/questions/6224626/github-clone-contents-of-a-repo-without-folder-itself — Marc, Mar 29 '15 at 12:38
@JoachimBreitner: That question is about *checking out* subdirectories in Git (which is easy), whereas this question is about *cloning* subdirectories in Git (which is impossible). — Jörg W Mittag, Aug 31 '18 at 14:48
@NickSergeant: As of Git 2.19, released 3 weeks ago, this is finally possible, as can be seen in this answer: https://stackoverflow.com/a/52269934/2988 Consider accepting that one now. Note: in Git 2.19, only client-side support is implemented, server-side support is still missing, so it only works when cloning local repositories. Also note that large Git hosters, e.g. GitHub don't actually use the Git server, they use their own implementation, so even if support shows up in the Git server, it does not automatically mean that it works on Git hosters. (OTOH, they could implement it faster.) — Jörg W Mittag, Nov 04 '18 at 09:22
**See also:** https://stackoverflow.com/questions/466303/git-branches-with-completely-different-content — dreftymac, Nov 14 '19 at 17:23
I've created a ``bash`` function which avoids downloading the history, which retrieves a single branch and which retrieves a list of files or directories you need. See it here: https://stackoverflow.com/questions/60190759/how-do-i-clone-fetch-or-sparse-checkout-a-single-directory-or-a-list-of-directo — Richard Gomes, Feb 12 '20 at 14:40
If you want to download a folder from a GitHub repo, https://download-directory.github.io/ might be just the thing — jemand771, May 04 '21 at 06:40
@jemand771 That was an excellent comment. Just what I needed. Thanks! — longliveenduro, May 19 '21 at 06:10

score 1601 · Answer 1 · edited Dec 04 '20 at 15:11

1601

What you are trying to do is called a sparse checkout, and that feature was added in git 1.7.0 (Feb. 2012). The steps to do a sparse clone are as follows:

mkdir <repo>
cd <repo>
git init
git remote add -f origin <url>

This creates an empty repository with your remote, and fetches all objects but doesn't check them out. Then do:

git config core.sparseCheckout true

Now you need to define which files/folders you want to actually check out. This is done by listing them in .git/info/sparse-checkout, eg:

echo "some/dir/" >> .git/info/sparse-checkout
echo "another/sub/tree" >> .git/info/sparse-checkout

Last but not least, update your empty repo with the state from the remote:

git pull origin master

You will now have files "checked out" for some/dir and another/sub/tree on your file system (with those paths still), and no other paths present.

You might want to have a look at the extended tutorial and you should probably read the official documentation for sparse checkout.

As a function:

function git_sparse_clone() (
  rurl="$1" localdir="$2" && shift 2

  mkdir -p "$localdir"
  cd "$localdir"

  git init
  git remote add -f origin "$rurl"

  git config core.sparseCheckout true

  # Loops over remaining args
  for i; do
    echo "$i" >> .git/info/sparse-checkout
  done

  git pull origin master
)

Usage:

git_sparse_clone "http://github.com/tj/n" "./local/location" "/bin"

Note that this will still download the whole repository from the server – only the checkout is reduced in size. At the moment it is not possible to clone only a single directory. But if you don't need the history of the repository, you can at least save on bandwidth by creating a shallow clone. See udondan's answer below for information on how to combine shallow clone and sparse checkout.

As of git 2.25.0 (Jan 2020) an experimental sparse-checkout command is added in git:

git sparse-checkout init
# same as: 
# git config core.sparseCheckout true

git sparse-checkout set "A/B"
# same as:
# echo "A/B" >> .git/info/sparse-checkout

git sparse-checkout list
# same as:
# cat .git/info/sparse-checkout

edited Dec 04 '20 at 15:11

Bruno Brant

7,558
5
40
76

answered Dec 06 '12 at 07:37

Chronial

55,303
13
76
85

1

FYI: if above is not working on windows, make sure you use something like this: `echo some/dir/*>> .git/info/sparse-checkout`, note it seems need to use `/*` and there is no space after it before the `>>`. – wangzq Jan 08 '13 at 00:09
1

This question is probably a duplicate of http://stackoverflow.com/questions/4114887/is-it-possible-to-do-a-sparse-checkout-without-checking-out-the-whole-repository . I'm commenting on this one because the last command generates the following error: "Sparse checkout leaves no entry on working directory". Instead, just checkout the desired branch (e.g, master) using: git checkout master. – metator Jan 25 '13 at 02:13
17

on Apple the '-f' perimeter does not work. just do git remote add origin without -f – Anno2001 Feb 17 '13 at 10:58
140

It is an improvement but still needs to download and store a full copy of the remote repository in origin, which one might like to avoid at all if he is interested only in portions of the codebase (or if there is documentation subfolders as in my case) – a1an Jun 13 '13 at 12:42
@a1an: in my case it did not make the full copy within ``, but maybe it is because I used a local repo on the disk instead of a remote repo. – basZero Aug 07 '13 at 15:34
57

Is there a way to clone desired directory contents (not directory itself) right into my repository? For example I want clone contents of `https://github.com/Umkus/nginx-boilerplate/tree/master/src` right into `/etc/nginx` – mac Apr 10 '14 at 05:40
3

Note that this still copies all the code locally, because adding a remote is an implied `fetch`. – ErikE May 14 '14 at 06:38
@ErikE That’s not quite correct. Adding a remote is not an implied fetch. The pull is the command that triggers a fetch. But the whole history is indeed downloaded there, as a1an already noted. Only the checkout is sparse. – Chronial May 14 '14 at 09:23
@Chronial I'm sorry, I missed that a1an already said the same thing. But I think you misunderstand fetch. Last night I ran `git remote add -f origin ` as given in this post, and git downloaded the entire 1.62GB repository. And there are 1.62GB of files in the .git folder. And `git branch -a` shows `/remotes/origin/branch`. It is **exactly** correct. Adding a remote is an implied, initial, `fetch`. – ErikE May 14 '14 at 18:26
25

@Chronial, @ErikE: you're both right / wrong :P The `git remote add` command does *not* imply a fetch, but `git remote add -f`, as used here, does! That's what the `-f` means. – ntc2 May 16 '14 at 00:02
Thank you for setting us straight, @ntc2! I should have looked/tested more carefully before opening my mouth. One more thing I learned about git. One less person on the internet is wrong, now! – ErikE May 16 '14 at 00:15
4

Has anyone been getting the error "error: Sparse checkout leaves no entry on working directory" when executing `git pull origin master` ? Before that error message, this was also print out: `*branch master -> FETCH_HEAD`. Can't seem to find the solution after looking at a lot of similar questions/posts. – LazerSharks Jul 18 '14 at 01:51
2

@Gnuey See @metator comment above! Use `git checkout master` instead. – Matthew Wilcoxson Aug 01 '14 at 12:55
1

@ntc2 : and you can do it fine without the -f, but then you have to pull it all when you run git pull origin master... regardless of the sparse checkout directory contents. – Erik Aronesty Aug 18 '14 at 16:39
23

Using this and `--depth=1` I cloned Chromium Devtools in 338 MB instead of 4.9 GB of full Blink source + history. Excellent. – Rudie Oct 22 '14 at 19:26
3

If like me you left some things out of `.git/info/sparse-checkout` the first time around, add them to that file and then do a `git reset --hard`. No additional `pull` required! – Jess Austin Nov 05 '14 at 19:22
5

This is not "subdirectory only", because when I do this I end up with a bunch of directories for the full path leading up to the subdirectory that I wanted. There seems to be no way to fit this into my existing source tree that I wanted to use it with, and still have it in a state where I can do commits. Man, every time I touch git I hate it more! – iforce2d Mar 03 '15 at 10:52
2

@iforce2d note that these sparse checkouts are just a hack and are not in any way how git is supposed to be used. If you need them, your project structure does not fit git. Git is not subversion. – Chronial Mar 03 '15 at 17:53
@Chronial "Git is not subversion" no, but in my case I'm trying to pull just the source portion of my repo down onto the server where it's hosted. I don't want all the other stuff! – Josh M. Jun 03 '15 at 20:59
@JoshM. Well, and iforce2d obviously was in different situation, as he wanted to commit. – Chronial Jun 04 '15 at 00:24
1

@Chronial,@Gnuey,@metator, Getting error "Sparse checkout leaves no entry on working directory". git checkout master also giving the same error. – CAD Dec 17 '15 at 07:31
It's not useful, by this approach it still need to clone all the repository instead of just part . – 柯鴻儀 Dec 18 '15 at 17:45
1

Worth pointing out that for the OP's case, the two sparse checkouts can share the same `.git` if they're on the same machine (or maybe even over NFS?), so you avoid having two copies of the full repo. (Or you could just have symlinks from two places into a normal full-tree clone of the repo, if it's ok to have them both parts of the working tree on the same filesystem.) – Peter Cordes Jun 15 '17 at 04:18
2

on windows `don't` use the quote sign by dir name: `dir`not `"dir"` – Mark Oct 27 '17 at 23:10
For those coming across the error "Sparse checkout leaves no entry on working directory" (@LazerSharks, @CAD,...), this may depend on the path of the folders. Please check it out whether https://stackoverflow.com/q/28852637/5459638 helps – XavierStuvw Aug 05 '19 at 06:47
I've created a ``bash`` function which avoids downloading the history, which retrieves a single branch and which retrieves a list of files or directories you need. See it here: https://stackoverflow.com/questions/60190759/how-do-i-clone-fetch-or-sparse-checkout-a-single-directory-or-a-list-of-directo – Richard Gomes Feb 12 '20 at 14:42
@Chromial: It might be worth adding partial clone to your answer, that would change it from "best answer, but doesn't fully address the question" to "the authoritative answer". I would love to see this selected as the actual answer. :) – Tao Apr 20 '20 at 15:49
https://stackoverflow.com/questions/4114887/is-it-possible-to-do-a-sparse-checkout-without-checking-out-the-whole-repository – R. Hoek Aug 28 '20 at 07:13
Fixed link to tutorial: https://jasonkarns.wordpress.com/2011/11/15/subdirectory-checkouts-with-git-sparse-checkout/ – Wheezil Jan 28 '21 at 13:58

Ciro Santilli新疆棉花TRUMP BAN BAD · Answer 2 · 2021-04-13T12:45:18.590

git clone --filter from git 2.19 now works on GitHub (tested 2021-01-14, git 2.30.0)

This option was added together with an update to the remote protocol, and it truly prevents objects from being downloaded from the server.

E.g., to clone only objects required for d1 of this minimal test repository: https://github.com/cirosantilli/test-git-partial-clone I can do:

git clone \
  --depth 1  \
  --filter=blob:none  \
  --sparse \
  https://github.com/cirosantilli/test-git-partial-clone \
;
cd test-git-partial-clone
git sparse-checkout set d1

Here's a less minimal and more realistic version at https://github.com/cirosantilli/test-git-partial-clone-big-small

git clone \
  --depth 1  \
  --filter=blob:none  \
  --sparse \
  https://github.com/cirosantilli/test-git-partial-clone-big-small \
;
cd test-git-partial-clone-big-small
git sparse-checkout set small

That repository contains:

a big directory with 10 10MB files
a small directory with 1000 files of size one byte

All contents are pseudo-random and therefore incompressible.

Clone times on my 36.4 Mbps internet:

full: 24s
partial: "instantaneous"

The sparse-checkout part is also needed unfortunately. You can also only download certain files with the much more understandable:

git clone \
  --depth 1  \
  --filter=blob:none  \
  --no-checkout \
  https://github.com/cirosantilli/test-git-partial-clone \
;
cd test-git-partial-clone
git checkout master -- di

but that method for some reason downloads files one by one very slowly, making it unusable unless you have very few files in the directory.

Analysis of the objects in the minimal repository

The clone command obtains only:

a single commit object with the tip of the master branch
all 4 tree objects of the repository:
- toplevel directory of commit
- the the three directories d1, d2, master

Then, the git sparse-checkout set command fetches only the missing blobs (files) from the server:

d1/a
d1/b

Even better, later on GitHub will likely start supporting:

  --filter=blob:none \
  --filter=tree:0 \

where --filter=tree:0 from Git 2.20 will prevent the unnecessary clone fetch of all tree objects, and allow it to be deferred to checkout. But on my 2020-09-18 test that fails with:

fatal: invalid filter-spec 'combine:blob:none+tree:0'

presumably because the --filter=combine: composite filter (added in Git 2.24, implied by multiple --filter) is not yet implemented.

I observed which objects were fetched with:

git verify-pack -v .git/objects/pack/*.pack

as mentioned at: How to list ALL git objects in the database? It does not give me a super clear indication of what each object is exactly, but it does say the type of each object (commit, tree, blob), and since there are so few objects in that minimal repo, I can unambiguously deduce what each object is.

git rev-list --objects --all did produce clearer output with paths for tree/blobs, but it unfortunately fetches some objects when I run it, which makes it hard to determine what was fetched when, let me know if anyone has a better command.

TODO find GitHub announcement that saying when they started supporting it. https://github.blog/2020-01-17-bring-your-monorepo-down-to-size-with-sparse-checkout/ from 2020-01-17 already mentions --filter blob:none.

git sparse-checkout

I think this command is meant to manage a settings file that says "I only care about these subtrees" so that future commands will only affect those subtrees. But it is a bit hard to be sure because the current documentation is a bit... sparse ;-)

It does not, by itself, prevent the fetching of blobs.

If this understanding is correct, then this would be a good complement to git clone --filter described above, as it would prevent unintentional fetching of more objects if you intend to do git operations in the partial cloned repo.

When I tried on Git 2.25.1:

git clone \
  --depth 1 \
  --filter=blob:none \
  --no-checkout \
  https://github.com/cirosantilli/test-git-partial-clone \
;
cd test-git-partial-clone
git sparse-checkout init

it didn't work because the init actually fetched all objects.

However, in Git 2.28 it didn't fetch the objects as desired. But then if I do:

git sparse-checkout set d1

d1 is not fetched and checked out, even though this explicitly says it should: https://github.blog/2020-01-17-bring-your-monorepo-down-to-size-with-sparse-checkout/#sparse-checkout-and-partial-clones With disclaimer:

Keep an eye out for the partial clone feature to become generally available[1].

[1]: GitHub is still evaluating this feature internally while it’s enabled on a select few repositories (including the example used in this post). As the feature stabilizes and matures, we’ll keep you updated with its progress.

So yeah, it's just too hard to be certain at the moment, thanks in part to the joys of GitHub being closed source. But let's keep an eye on it.

Command breakdown

The server should be configured with:

git config --local uploadpack.allowfilter 1
git config --local uploadpack.allowanysha1inwant 1

Command breakdown:

--filter=blob:none skips all blobs, but still fetches all tree objects
--filter=tree:0 skips the unneeded trees: https://www.spinics.net/lists/git/msg342006.html
--depth 1 already implies --single-branch, see also: How do I clone a single branch in Git?
file://$(path) is required to overcome git clone protocol shenanigans: How to shallow clone a local git repository with a relative path?
--filter=combine:FILTER1+FILTER2 is the syntax to use multiple filters at once, trying to pass --filter for some reason fails with: "multiple filter-specs cannot be combined". This was added in Git 2.24 at e987df5fe62b8b29be4cdcdeb3704681ada2b29e "list-objects-filter: implement composite filters"

Edit: on Git 2.28, I experimentally see that --filter=FILTER1 --filter FILTER2 also has the same effect, since GitHub does not implement combine: yet as of 2020-09-18 and complains fatal: invalid filter-spec 'combine:blob:none+tree:0'. TODO introduced in which version?

The format of --filter is documented on man git-rev-list.

Docs on Git tree:

Test it out locally

The following script reproducibly generates the https://github.com/cirosantilli/test-git-partial-clone repository locally, does a local clone, and observes what was cloned:

#!/usr/bin/env bash
set -eu

list-objects() (
  git rev-list --all --objects
  echo "master commit SHA: $(git log -1 --format="%H")"
  echo "mybranch commit SHA: $(git log -1 --format="%H")"
  git ls-tree master
  git ls-tree mybranch | grep mybranch
  git ls-tree master~ | grep root
)

# Reproducibility.
export GIT_COMMITTER_NAME='a'
export GIT_COMMITTER_EMAIL='a'
export GIT_AUTHOR_NAME='a'
export GIT_AUTHOR_EMAIL='a'
export GIT_COMMITTER_DATE='2000-01-01T00:00:00+0000'
export GIT_AUTHOR_DATE='2000-01-01T00:00:00+0000'

rm -rf server_repo local_repo
mkdir server_repo
cd server_repo

# Create repo.
git init --quiet
git config --local uploadpack.allowfilter 1
git config --local uploadpack.allowanysha1inwant 1

# First commit.
# Directories present in all branches.
mkdir d1 d2
printf 'd1/a' > ./d1/a
printf 'd1/b' > ./d1/b
printf 'd2/a' > ./d2/a
printf 'd2/b' > ./d2/b
# Present only in root.
mkdir 'root'
printf 'root' > ./root/root
git add .
git commit -m 'root' --quiet

# Second commit only on master.
git rm --quiet -r ./root
mkdir 'master'
printf 'master' > ./master/master
git add .
git commit -m 'master commit' --quiet

# Second commit only on mybranch.
git checkout -b mybranch --quiet master~
git rm --quiet -r ./root
mkdir 'mybranch'
printf 'mybranch' > ./mybranch/mybranch
git add .
git commit -m 'mybranch commit' --quiet

echo "# List and identify all objects"
list-objects
echo

# Restore master.
git checkout --quiet master
cd ..

# Clone. Don't checkout for now, only .git/ dir.
git clone --depth 1 --quiet --no-checkout --filter=blob:none "file://$(pwd)/server_repo" local_repo
cd local_repo

# List missing objects from master.
echo "# Missing objects after --no-checkout"
git rev-list --all --quiet --objects --missing=print
echo

echo "# Git checkout fails without internet"
mv ../server_repo ../server_repo.off
! git checkout master
echo

echo "# Git checkout fetches the missing directory from internet"
mv ../server_repo.off ../server_repo
git checkout master -- d1/
echo

echo "# Missing objects after checking out d1"
git rev-list --all --quiet --objects --missing=print

GitHub upstream.

Output in Git v2.19.0:

# List and identify all objects
c6fcdfaf2b1462f809aecdad83a186eeec00f9c1
fc5e97944480982cfc180a6d6634699921ee63ec
7251a83be9a03161acde7b71a8fda9be19f47128
62d67bce3c672fe2b9065f372726a11e57bade7e
b64bf435a3e54c5208a1b70b7bcb0fc627463a75 d1
308150e8fddde043f3dbbb8573abb6af1df96e63 d1/a
f70a17f51b7b30fec48a32e4f19ac15e261fd1a4 d1/b
84de03c312dc741d0f2a66df7b2f168d823e122a d2
0975df9b39e23c15f63db194df7f45c76528bccb d2/a
41484c13520fcbb6e7243a26fdb1fc9405c08520 d2/b
7d5230379e4652f1b1da7ed1e78e0b8253e03ba3 master
8b25206ff90e9432f6f1a8600f87a7bd695a24af master/master
ef29f15c9a7c5417944cc09711b6a9ee51b01d89
19f7a4ca4a038aff89d803f017f76d2b66063043 mybranch
1b671b190e293aa091239b8b5e8c149411d00523 mybranch/mybranch
c3760bb1a0ece87cdbaf9a563c77a45e30a4e30e
a0234da53ec608b54813b4271fbf00ba5318b99f root
93ca1422a8da0a9effc465eccbcb17e23015542d root/root
master commit SHA: fc5e97944480982cfc180a6d6634699921ee63ec
mybranch commit SHA: fc5e97944480982cfc180a6d6634699921ee63ec
040000 tree b64bf435a3e54c5208a1b70b7bcb0fc627463a75    d1
040000 tree 84de03c312dc741d0f2a66df7b2f168d823e122a    d2
040000 tree 7d5230379e4652f1b1da7ed1e78e0b8253e03ba3    master
040000 tree 19f7a4ca4a038aff89d803f017f76d2b66063043    mybranch
040000 tree a0234da53ec608b54813b4271fbf00ba5318b99f    root

# Missing objects after --no-checkout
?f70a17f51b7b30fec48a32e4f19ac15e261fd1a4
?8b25206ff90e9432f6f1a8600f87a7bd695a24af
?41484c13520fcbb6e7243a26fdb1fc9405c08520
?0975df9b39e23c15f63db194df7f45c76528bccb
?308150e8fddde043f3dbbb8573abb6af1df96e63

# Git checkout fails without internet
fatal: '/home/ciro/bak/git/test-git-web-interface/other-test-repos/partial-clone.tmp/server_repo' does not appear to be a git repository
fatal: Could not read from remote repository.

Please make sure you have the correct access rights
and the repository exists.

# Git checkout fetches the missing directory from internet
remote: Enumerating objects: 1, done.
remote: Counting objects: 100% (1/1), done.
remote: Total 1 (delta 0), reused 0 (delta 0)
Receiving objects: 100% (1/1), 45 bytes | 45.00 KiB/s, done.
remote: Enumerating objects: 1, done.
remote: Counting objects: 100% (1/1), done.
remote: Total 1 (delta 0), reused 0 (delta 0)
Receiving objects: 100% (1/1), 45 bytes | 45.00 KiB/s, done.

# Missing objects after checking out d1
?8b25206ff90e9432f6f1a8600f87a7bd695a24af
?41484c13520fcbb6e7243a26fdb1fc9405c08520
?0975df9b39e23c15f63db194df7f45c76528bccb

Conclusions: all blobs from outside of d1/ are missing. E.g. 0975df9b39e23c15f63db194df7f45c76528bccb, which is d2/b is not there after checking out d1/a.

Note that root/root and mybranch/mybranch are also missing, but --depth 1 hides that from the list of missing files. If you remove --depth 1, then they show on the list of missing files.

I have a dream

This feature could revolutionize Git.

Imagine having all the code base of your enterprise in a single repo without ugly third-party tools like repo.

Imagine storing huge blobs directly in the repo without any ugly third party extensions.

Imagine if GitHub would allow per file / directory metadata like stars and permissions, so you can store all your personal stuff under a single repo.

Imagine if submodules were treated exactly like regular directories: just request a tree SHA, and a DNS-like mechanism resolves your request, first looking on your local ~/.git, then first to closer servers (your enterprise's mirror / cache) and ending up on GitHub.

Oddly, on macOS with git version 2.20.1 (Apple Git-117), it complains that "multiple filter-specs cannot be combined" — muru, Dec 03 '19 at 09:06
@muru thanks for pointing this out. I had written the answer before the `tree:0` was out, and just supposed it would work to add another filter without testing. I saw now that there is however a new syntax to do it, updated (also untested, but copied from docs :-)) — Ciro Santilli新疆棉花TRUMP BAN BAD, Dec 03 '19 at 09:22
Sadly, no luck with the macOS git version. `fatal: invalid filter-spec 'combine:blob:none+tree:0'` Thanks anyway! Maybe it will work with newer versions. — muru, Dec 06 '19 at 07:51
@muru was only added in git 2.24 as mentioned in answer BTW. Let me know if you test a newer git and it still fails. — Ciro Santilli新疆棉花TRUMP BAN BAD, Dec 06 '19 at 08:05
This fails when trying it on Windows 10 using GIT 2.24.1 (throws tons of "unable to read sha1 file of.." + "Unlink of file xxx failed."). Worked as a charm with same version on Linux. — Oyvind, Dec 16 '19 at 11:40
@Oyvind thanks for the report. Let me know if you find anything about it, or consider opening a bug report upstream and linking to it on a comment. — Ciro Santilli新疆棉花TRUMP BAN BAD, Dec 16 '19 at 11:41
@Ciro Santilli This still fails with "unable to read sha1 file of..." in git version 2.26.1.windows.1. I opened a bug report: https://github.com/git-for-windows/git/issues/2590 — nharrer, Apr 18 '20 at 16:43
@Ciro Santilli So far the clone/checkout worked well (on linux). However a `git status` or `git commit` would still pull in the full server repository unless I did a sparse checkout on top of it. Like this: https://gist.github.com/nharrer/33b1535b4630387ff2be3116513baa0b — nharrer, Apr 18 '20 at 20:41
tried `git checkout master -- some/path` on a real repo and it downloads each file one by one making it rather slow. Any idea how to make it checkout all the files at once? — Faboor, Jan 06 '21 at 11:03
@Faboor do you mean `some/path` is a directory and it downloads individual paths within the directory? Or you are making several calls with different paths `some/path1`, `some/path2`? For several calls, does `git checkout master -- some/path1 some/path2` not work? — Ciro Santilli新疆棉花TRUMP BAN BAD, Jan 06 '21 at 11:13
@CiroSantilli郝海东冠状病六四事件法轮功 `some/path` is a directory and `git checkout master -- some/path` correctly clones only files in that directory and its subdirs - but it does it one by one with a message like: `remote: Enumerating objects: 1, done. remote: Counting objects: 100% (1/1), done. remote: Total 1 (delta 0), reused 1 (delta 0), pack-reused 0 Receiving objects: 100% (1/1), 51 bytes | 51.00 KiB/s, done.` These 4 lines repeated for each of the 90 files in the dir and its subdirs (this is on `git version 2.24.3 (Apple Git-128)`) — Faboor, Jan 06 '21 at 11:33
@Faboor OK, then I don't know. I recommend opening a separate question, with a minimal reproducible test repo and the clone time difference between full/partial clone, and link to it from a comment here, I'd be curious to understand what is going on. — Ciro Santilli新疆棉花TRUMP BAN BAD, Jan 06 '21 at 11:38
@PaulBeusterien reproduction at: https://github.com/isaacs/github/issues/1888 — Ciro Santilli新疆棉花TRUMP BAN BAD, Jan 14 '21 at 20:05
You almost certainly don't want the 'git sparse-checkout init --cone'. The effect of that is to also check-out all files in parent directories, as well as the tree you actually want. Without it you just get the tree you requested. — Mike Moreton, Apr 12 '21 at 13:17
@MikeMoreton I didn't know that, let me know if you find a solution without it. Even with that, it is generally what most people will want I believe. — Ciro Santilli新疆棉花TRUMP BAN BAD, Apr 12 '21 at 19:03
@CiroSantilli新疆棉花TRUMPBANBAD - you've already found the solution! Just remove the --cone line and it will work fine. In your test repository try creating an additional file at the top level. If you follow your instructions, then you'll also get a copy of that file as well as the directory you want. Remove the 'git sparse-checkout init --cone' but follow all your other instructions, and you'll just get the directory tree you want. I'm not quite sure in what circumstances you'd want to use --cone! — Mike Moreton, Apr 13 '21 at 11:57
@MikeMoreton thanks, I thought I had tested and found that it was necessary, but I can't reproduce now, so I think I was actually just copying commands from other people. Removed that `git sparse-checkout init --cone`. — Ciro Santilli新疆棉花TRUMP BAN BAD, Apr 13 '21 at 12:46

score 713 · Accepted Answer · edited Dec 16 '19 at 17:12

713

EDIT: As of Git 2.19, this is finally possible, as can be seen in this answer.

Consider upvoting that answer.

Note: in Git 2.19, only client-side support is implemented, server-side support is still missing, so it only works when cloning local repositories. Also note that large Git hosters, e.g. GitHub, don't actually use the Git server, they use their own implementation, so even if support shows up in the Git server, it does not automatically mean that it works on Git hosters. (OTOH, since they don't use the Git server, they could implement it faster in their own implementations before it shows up in Git server.)

No, that's not possible in Git.

Implementing something like this in Git would be a substantial effort and it would mean that the integrity of the clientside repository could no longer be guaranteed. If you are interested, search for discussions on "sparse clone" and "sparse fetch" on the git mailinglist.

In general, the consensus in the Git community is that if you have several directories that are always checked out independently, then these are really two different projects and should live in two different repositories. You can glue them back together using Git Submodules.

edited Dec 16 '19 at 17:12

Saurabh P Bhandari

4,338
1
7
34

answered Mar 01 '09 at 18:00

Jörg W Mittag

337,159
71
413
614

6

Depending on the scenario, you may want to use git subtree instead of git submodule. See http://alumnit.ca/~apenwarr/log/?m=200904#30 – C Pirate Aug 03 '09 at 17:12
10

@StijndeWitt: Sparse checkouts happen during `git-read-tree`, which is long after `get-fetch`. The question was not about checking out only a subdirectory, it was about *cloning* only a subdirectory. I don't see how sparse checkouts could possibly do that, since `git-read-tree` runs after the clone has already completed. – Jörg W Mittag Mar 06 '14 at 14:53
To help you show only the directory you want, you have to execute git read-tree -m -u HEAD – JackXu May 28 '15 at 06:08
10

Rather than this "stub", would you like for me to delete this answer so Chronial's can float to the top? You can't delete it yourself, because it's accepted, but a moderator can. You would keep the reputation you've earned from it, since it's so old. (I came across this because someone flagged it as "link-only". :-) – Cody Gray Aug 21 '17 at 17:49
You can download a subfolder by using this site here: http://kinolien.github.io/gitzip/ Just download a subfolder without entering a Github Access token ... – Legends Mar 01 '18 at 23:36
1

@CodyGray: Chronial answer *still* clones the entire repository, and *not* only a subdirectory. (The last paragraph even explicitly says so.) Cloning only a subdirectory is *not possible* in Git. The network protocol doesn't support it, the storage format doesn't support it. *Every single answer to this question* always clones the whole repository. The question is a simple Yes/No question, and the answer is two characters: No. If at all, my answer is unnecessarily *long*, not short. – Jörg W Mittag Aug 31 '18 at 14:45
1

@JörgWMittag: [Ciro Santili's answer](https://stackoverflow.com/a/52269934/1269037) seems to contradict you. – Dan Dascalescu Nov 04 '18 at 00:53
"if you have several directories that are always checked out independently, then these are really two different projects and should live in two different repositories" - what about checking out a microservice that's part of a monorepo, on the machine on which it is to be deployed? – Dan Dascalescu Nov 04 '18 at 00:55
@DanDascalescu note that my answer documents a very recent feature, possibly it was not merged when Jorg commented :-) I'm so excited... now you Googlers and all other big enterprises will be able to actually keep your monolithic Git repo sanely without extra tooling. Just hope web UI's start adding per folder metadata, e.g. per folder stars / permissions. – Ciro Santilli新疆棉花TRUMP BAN BAD Nov 21 '18 at 20:50
Can you do it on TortoiseGit? – Alaa M. Jan 22 '20 at 11:54
I've created a ``bash`` function which avoids downloading the history, which retrieves a single branch and which retrieves a list of files or directories you need. See it here: https://stackoverflow.com/questions/60190759/how-do-i-clone-fetch-or-sparse-checkout-a-single-directory-or-a-list-of-directo – Richard Gomes Feb 12 '20 at 14:42
GitHub now has full support BTW as per updates on my answer :) – Ciro Santilli新疆棉花TRUMP BAN BAD Feb 02 '21 at 19:31

udondan · Answer 4 · 2015-02-25T00:22:18.753

425

You can combine the sparse checkout and the shallow clone features. The shallow clone cuts off the history and the sparse checkout only pulls the files matching your patterns.

git init <repo>
cd <repo>
git remote add origin <url>
git config core.sparsecheckout true
echo "finisht/*" >> .git/info/sparse-checkout
git pull --depth=1 origin master

You'll need minimum git 1.9 for this to work. Tested it myself only with 2.2.0 and 2.2.2.

This way you'll be still able to push, which is not possible with git archive.

edited Feb 25 '15 at 00:22

answered Jan 20 '15 at 07:33

udondan

48,050
17
168
161

what would be the echo path for this: `https://github.com/tastejs/todomvc/tree/master/examples/angularjs` just `examples/angularjs/*` ? – SuperUberDuper Jul 14 '15 at 13:56
I guess that would be `tastejs/todomvc/tree/master/examples/angularjs just examples/angularjs/*`. – udondan Jul 14 '15 at 14:49
25

This is useful, and may be the best available answer, but it still *clones* the content that you don't care about (if it is on the branch that you pull), even though it doesn't show up in the checkout. – Brent Bradburn Aug 25 '15 at 21:54
This does not work for me. --depth=1 is ignored, still tries to pull several thousand commits and about 100x too many files. – Tyguy7 Sep 18 '15 at 21:46
1

What is your git version? According to git help is the depth option available? – udondan Sep 19 '15 at 05:14
worked like a charm with git 1.9.1. exactly what I was looking for. – infoclogged Dec 10 '15 at 19:03
2

doesn't work for me when the last command is not `git pull --depth=1 origin master` but `git pull --depth=1 origin `. this is so strange, see my question here： http://stackoverflow.com/questions/35820630/how-do-i-checkout-a-sub-direcotry-in-a-huge-git-repo-with-specified-branch-and-w – Shuman Mar 06 '16 at 00:15
5

On Windows, the second-to-last line needs to omit the quotes, or the pull fails. – nateirvin Mar 31 '16 at 17:01
1

Still fetches all but checks out as expected. git `2.6.4`. – MadeOfAir May 14 '16 at 20:29
4

This still downloads all data! Found this solution, using svn: http://stackoverflow.com/a/18324458/2302437 – electronix384128 May 18 '16 at 00:09
1

How to only fetch files inside sub directory? – Babish Shrestha Sep 03 '16 at 04:49
@BabishShrestha set the path is the sparse-checkout file accordingly – udondan Sep 03 '16 at 10:30
@udondan I tried but It pulls the subdirectory folder every time. For example, the subdirectory is "src" and there are files inside src. Then with sparse checkout instead of fetching files inside src folder, it fetches files along with the src folder. – Babish Shrestha Sep 04 '16 at 15:08
This is the cleanest answer! @udondan, then, what should I do, so as to push the mirrored repo to under my own github account? I tried to `git remote add origin` again, but got `fatal: remote origin already exists.`. Moreover, when the original repo updated, how should I update my own github repo? Thx – xpt Apr 20 '17 at 22:18
This is suppose to be the correct answer, you are the best brah, simple and short – 0.sh Aug 26 '17 at 02:21
@udondan You missed a `git fetch --all`. This won't work if i have to pull a subdirectory and switch to an existing branch. – Aseem Upadhyay Mar 03 '18 at 06:33
This gets the job done. The only downside is that we lose our commit history and that's a big one for me – ksadjad Aug 07 '19 at 05:34

score 177 · Answer 5 · edited Jun 18 '18 at 11:32

177

For other users who just want to download a file/folder from github, simply use:

svn export <repo>/trunk/<folder>

e.g.

svn export https://github.com/lodash/lodash.com/trunk/docs

(yes, that's svn here. apparently in 2016 you still need svn to simply download some github files)

Courtesy: Download a single folder or directory from a GitHub repo

Important - Make sure you update the github URL and replace /tree/master/ with '/trunk/'.

As bash script:

git-download(){
    folder=${@/tree\/master/trunk}
    folder=${folder/blob\/master/trunk}
    svn export $folder
}

Note This method downloads a folder, does not clone/checkout it. You can't push changes back to the repository. On the other hand - this results in smaller download compared to sparse checkout or shallow checkout.

edited Jun 18 '18 at 11:32

Amit G

2,095
2
20
43

answered Sep 04 '16 at 13:02

Anona112

3,266
3
17
30

11

only version which worked for me with github. The git commands checked out >10k files, the svn export only the 700 i wanted. Thanks! – Christopher Lörken Feb 01 '17 at 18:19
4

Tried doing this with `https://github.com/tensorflow/tensorflow/tree/master/tensorflow/examples/trunk/udacity` but got `svn: E170000: URL 'https://github.com/tensorflow/tensorflow/tree/master/tensorflow/examples/trunk/udacity' doesn't exist` error :( – zthomas.nc Feb 19 '17 at 21:55
11

@zthomas.nc You need to remove the 'trunk' preceding udacity, and replace /tree/master/ with /trunk/ instead. – Speedy Mar 22 '17 at 17:01
This doesn't create an actual repo I can commit to etc does it? – Dominic Mar 22 '17 at 22:55
2

This command was the one that worked for me! I just wanted to get a copy of a file from a repo so I could modify it locally. Good old SVN to the rescue! – Michael J Jun 02 '17 at 00:32
3

it works, but seems slow. takes a bit to start and then the files roll by relatively slowly – Aryeh Beitz Dec 24 '17 at 10:15
1

Does anyone have something similar which works on bitbucket? – N M Mar 22 '18 at 03:07
1

unfortunately does not work for me: seems to be hanging and nothing happens further :-( Is there a way to diagnose what's going on _under the hood_? I had to kill it after waiting a minute or so.... – Orco Jun 11 '18 at 23:35
1

Pro-tip: if you want to use the SVN method but you want to use git locally, use git svn clone instead – LaPingvino Apr 30 '19 at 14:44
It works nicely, but extremely slow. It takes 5 seconds to download 4 small files. – Slava Fomin II Nov 01 '19 at 11:58
1

I confirm that in 2020 it still works. It was just what I needed, so I just clone my project directory in the VM and the rest remains private in my GIT. Thank you very much for the solution. – junihh Aug 25 '20 at 20:41
What if you want to specify a branch that's not the master branch? – Godstime Osarobo Apr 01 '21 at 06:07

score 74 · Answer 6 · edited Jun 14 '15 at 09:09

74

If you never plan to interact with the repository from which you cloned, you can do a full git clone and rewrite your repository using git filter-branch --subdirectory-filter. This way, at least the history will be preserved.

edited Jun 14 '15 at 09:09

udondan

48,050
17
168
161

answered Mar 01 '09 at 21:17

hillu

8,816
4
22
27

12

For people that doesn't know the command, it is `git filter-branch --subdirectory-filter ` – Jaime Hablutzel Oct 26 '14 at 14:32
9

This method has the advantage that the subdirectory you choose becomes the root of the new repository, which happens to be exactly what I want. – Andrew Schulman Dec 23 '14 at 21:27
That's defenitly the best and easiest approach to use. Here's a one-step command using subdirectory-filter `git clone https://github.com/your/repo_xx.git && cd repo_xx && git filter-branch --subdirectory-filter repo_xx_subdir` – Alex Nov 03 '19 at 04:55

score 67 · Answer 7 · edited Sep 02 '16 at 19:22

67

This looks far simpler:

git archive --remote=<repo_url> <branch> <path> | tar xvf -

edited Sep 02 '16 at 19:22

Peter Mortensen

28,342
21
95
123

answered Sep 10 '14 at 17:03

ErichBSchulz

12,945
5
47
50

18

When I do this on github I get fatal: Operation not supported by protocol. Unexpected end of command stream – Michael Fox Sep 25 '14 at 17:37
1

The protocol error could be because of HTTPS or : in the repo url. It could also be because of missing ssh key. – Umair A. Dec 07 '14 at 17:34
2

If you're using github you can use `svn export` instead – Milo Wielondek Jul 05 '15 at 15:25
2

Won't work wiht Github --> Invalid command: 'git-upload-archive 'xxx/yyy.git'' You appear to be using ssh to clone a git:// URL. Make sure your core.gitProxy config option and the GIT_PROXY_COMMAND environment variable are NOT set. fatal: The remote end hung up unexpectedly – Nianliang Jul 14 '15 at 15:19
1

Does this actually *clone* a piece of a repo (with git metadata), or just *download/extract* the subdirectory tree? – LarsH Oct 15 '15 at 19:21
4

The reason why this doesn't work with GitHub: "We don't support using git-archive to pull an archive directly from GitHub. You can either clone the repo locally and run git-archive, or click on the Download ZIP button on the repo page." https://github.com/xuwupeng2000/capistrano-scm-gitcopy/issues/16 – Donn Lee Aug 29 '16 at 23:17
1

@LarsH no, this just extracts the archive that is downloaded through some Git APIs. – kb1000 May 20 '18 at 16:06

score 63 · Answer 8 · edited Jun 06 '12 at 04:42

Git 1.7.0 has “sparse checkouts”. See “core.sparseCheckout” in the git config manpage, “Sparse checkout” in the git read-tree manpage, and “Skip-worktree bit” in the git update-index manpage.

The interface is not as convenient as SVN’s (e.g. there is no way to make a sparse checkout at the time of an initial clone), but the base functionality upon which simpler interfaces could be built is now available.

kenorb · Answer 9 · 2016-07-21T22:12:12.487

It's not possible to clone subdirectory only with Git, but below are few workarounds.

Filter branch

You may want to rewrite the repository to look as if trunk/public_html/ had been its project root, and discard all other history (using filter-branch), try on already checkout branch:

git filter-branch --subdirectory-filter trunk/public_html -- --all

^{Notes: The -- that separates filter-branch options from revision options, and the --all to rewrite all branches and tags. All information including original commit times or merge information will be preserved. This command honors .git/info/grafts file and refs in the refs/replace/ namespace, so if you have any grafts or replacement refs defined, running this command will make them permanent.}

Warning! The rewritten history will have different object names for all the objects and will not converge with the original branch. You will not be able to easily push and distribute the rewritten branch on top of the original branch. Please do not use this command if you do not know the full implications, and avoid using it anyway, if a simple single commit would suffice to fix your problem.

Sparse checkout

Here are simple steps with sparse checkout approach which will populate the working directory sparsely, so you can tell Git which folder(s) or file(s) in the working directory are worth checking out.

Clone repository as usual (--no-checkout is optional):
```
git clone --no-checkout git@foo/bar.git
cd bar
```
^{You may skip this step, if you've your repository already cloned.}

Hint: For large repos, consider shallow clone (--depth 1) to checkout only latest revision or/and --single-branch only.
Enable sparseCheckout option:
```
git config core.sparseCheckout true
```
Specify folder(s) for sparse checkout (without space at the end):
```
echo "trunk/public_html/*"> .git/info/sparse-checkout
```
or edit .git/info/sparse-checkout.
Checkout the branch (e.g. master):
```
git checkout master
```

Now you should have selected folders in your current directory.

You may consider symbolic links if you've too many levels of directories or filtering branch instead.

@sam: no. `filter-branch` would rewrite the parent commits so they'd have different SHA1 IDs, and thus your filtered tree would have no commits in common with the remote tree. `git pull` wouldn't know where to try to merge from. — Peter Cordes, Jun 15 '17 at 04:06

score 9 · Answer 10 · edited Sep 02 '16 at 19:22

9

I just wrote a script for GitHub.

Usage:

python get_git_sub_dir.py path/to/sub/dir <RECURSIVE>

edited Sep 02 '16 at 19:22

Peter Mortensen

28,342
21
95
123

answered Jan 23 '14 at 18:49

david_adler

5,354
4
39
64

11

FYI, that's for _GitHub_ only. – Sz. May 25 '14 at 14:49
9

And apparently this is for **downloading** a directory, not **cloning** a piece of a repo with all its metadata... right? – LarsH Oct 15 '15 at 19:18
8

You should include you code here and not somewhere else. – jww Dec 31 '18 at 07:13
urllib2.HTTPError: HTTP Error 403: rate limit exceeded – diyism May 18 '20 at 09:32

score 9 · Answer 11 · answered Mar 22 '19 at 04:01

9

This will clone a specific folder and remove all history not related to it.

git clone --single-branch -b {branch} git@github.com:{user}/{repo}.git
git filter-branch --subdirectory-filter {path/to/folder} HEAD
git remote remove origin
git remote add origin git@github.com:{user}/{new-repo}.git
git push -u origin master

answered Mar 22 '19 at 04:01

BARJ

925
1
14
22

Here be dragons. You get greeted by _WARNING: git-filter-branch has a glut of gotchas generating mangled history rewrites.._. Then the [git-filter-branch docs](https://htmlpreview.github.io/?https://raw.githubusercontent.com/newren/git-filter-repo/docs/html/git-filter-branch.html#SAFETY) has a rather long warning list. – Oyvind Dec 16 '19 at 12:05

score 6 · Answer 12 · edited Oct 28 '19 at 09:03

6

Here's a shell script I wrote for the use case of a single subdirectory sparse checkout

coSubDir.sh

localRepo=$1
remoteRepo=$2
subDir=$3


# Create local repository for subdirectory checkout, make it hidden to avoid having to drill down to the subfolder
mkdir ./.$localRepo
cd ./.$localRepo
git init
git remote add -f origin $remoteRepo
git config core.sparseCheckout true

# Add the subdirectory of interest to the sparse checkout.
echo $subDir >> .git/info/sparse-checkout

git pull origin master

# Create convenience symlink to the subdirectory of interest
cd ..
ln -s ./.$localRepo/$subDir $localRepo

edited Oct 28 '19 at 09:03

fduff

3,359
2
25
33

answered Mar 08 '18 at 19:39

jxramos

4,984
4
39
76

2

Nice script, only something which should be fixed is the symlink, should be `ln -s ./.$localRepo/$subDir $localRepo` instead of `ln -s ./.$localRepo$subDir $localRepo` – valentin_nasta Mar 16 '18 at 08:33

Everett · Answer 13 · 2020-12-21T13:21:43.677

Just to clarify some of the great answers here, the steps outlined in many of the answers assume that you already have a remote repository somewhere.

Given: an existing git repository, e.g. git@github.com:some-user/full-repo.git, with one or more directories that you wish to pull independently of the rest of the repo, e.g. directories named app1 and app2

Assuming you have a git repository as the above...

Then: you can run steps like the following to pull only specific directories from that larger repo:

mkdir app1
cd app1
git init
git remote add origin git@github.com:some-user/full-repo.git
git config core.sparsecheckout true
echo "app1/" >> .git/info/sparse-checkout
git pull origin master

I had mistakenly thought that the sparse-checkout options had to be set on the original repository, but this is not the case: you define which directories you want locally, prior to pulling from the remote. The remote repo doesn't know or care about your only wanting to track a part of the repo.

Hope this clarification helps someone else.

this is a bit late but what do i do if i need all contents inside app1 and not the app1 directory — Swapnil Shende, Aug 03 '20 at 15:26
That seems more like a cosmetic question, although it does seem like you don't have full freedom to "escape" the structure of the original repo. Maybe you could use symlinks? — Everett, Dec 21 '20 at 13:23

score 3 · Answer 14 · answered Dec 11 '19 at 00:31

Using Linux? And only want easy to access and clean working tree ? without bothering rest of code on your machine. try symlinks!

git clone https://github.com:{user}/{repo}.git ~/my-project
ln -s ~/my-project/my-subfolder ~/Desktop/my-subfolder

Test

cd ~/Desktop/my-subfolder
git status

score 2 · Answer 15 · answered Jul 26 '19 at 23:48

I wrote a .gitconfig [alias] for performing a "sparse checkout". Check it out (no pun intended):

On Windows run in cmd.exe

git config --global alias.sparse-checkout "!f(){ [ $# -eq 2 ] && L=${1##*/} L=${L%.git} || L=$2; mkdir -p \"$L/.git/info\" && cd \"$L\" && git init --template= && git remote add origin \"$1\" && git config core.sparseCheckout 1; [ $# -eq 2 ] && echo \"$2\" >> .git/info/sparse-checkout || { shift 2; for i; do echo $i >> .git/info/sparse-checkout; done }; git pull --depth 1 origin master;};f"

Otherwise:

git config --global alias.sparse-checkout '!f(){ [ $# -eq 2 ] && L=${1##*/} L=${L%.git} || L=$2; mkdir -p "$L/.git/info" && cd "$L" && git init --template= && git remote add origin "$1" && git config core.sparseCheckout 1; [ $# -eq 2 ] && echo "$2" >> .git/info/sparse-checkout || { shift 2; for i; do echo $i >> .git/info/sparse-checkout; done }; git pull --depth 1 origin master;};f'

Usage:

# Makes a directory ForStackExchange with Plug checked out
git sparse-checkout https://github.com/YenForYang/ForStackExchange Plug

# To do more than 1 directory, you have to specify the local directory:
git sparse-checkout https://github.com/YenForYang/ForStackExchange ForStackExchange Plug Folder

The git config commands are 'minified' for convenience and storage, but here is the alias expanded:

# Note the --template= is for disabling templates.
# Feel free to remove it if you don't have issues with them (like I did)
# `mkdir` makes the .git/info directory ahead of time, as I've found it missing sometimes for some reason
f(){
    [ "$#" -eq 2 ] && L="${1##*/}" L=${L%.git} || L=$2;
    mkdir -p "$L/.git/info"
        && cd "$L"
        && git init --template=
        && git remote add origin "$1"
        && git config core.sparseCheckout 1;
    [ "$#" -eq 2 ]
        && echo "$2" >> .git/info/sparse-checkout
        || {
            shift 2;
            for i; do
                echo $i >> .git/info/sparse-checkout;
            done
        };
    git pull --depth 1 origin master;
};
f

Why does this work: `L=${1##*/} L=${L%.git}` ? Is space an operator? — Gulzt, Dec 13 '19 at 12:33
You ought to mention this is for git < 2.25.0 (Jan 2020), which includes its own version of `git sparse-checkout`. — Nickolay, Aug 19 '20 at 19:09

score 1 · Answer 16 · answered Jan 25 '20 at 14:07

1

If you're actually ony interested in the latest revision files of a directory, Github lets you download a repository as Zip file, which does not contain history. So downloading is very much faster.

answered Jan 25 '20 at 14:07

weberjn

1,535
17
21

score 1 · Answer 17 · answered Apr 08 '21 at 13:15

Lots of great responses here, but I wanted to add that using the quotations around the directory names was failing for me on Windows Sever 2016. The files simply were not being downloaded.

Instead of

"mydir/myfolder"

I had to use

mydir/myfolder

Also, if you want to simply download all sub directories just use

git sparse-checkout set *

score 0 · Answer 18 · answered Jan 07 '20 at 13:52

While I hate actually having to use svn when dealing with git repos :/ I use this all the time;

function git-scp() (
  URL="$1" && shift 1
  svn export ${URL/blob\/master/trunk}
)

This allows you to copy out from the github url without modification. Usage;

--- /tmp » git-scp https://github.com/dgraph-io/dgraph/blob/master/contrib/config/kubernetes/helm                                                                                                                  1 ↵
A    helm
A    helm/Chart.yaml
A    helm/README.md
A    helm/values.yaml
Exported revision 6367.

--- /tmp » ls | grep helm
Permissions Size User    Date Modified    Name
drwxr-xr-x     - anthony 2020-01-07 15:53 helm/

score 0 · Answer 19 · answered Mar 08 '21 at 12:52

Lots of good ideas and scripts above. I could not help myself and combined them into a bash script with help and error checking:

#!/bin/bash

function help {
  printf "$1
Clones a specific directory from the master branch of a git repository.

Syntax:
  $(basename $0) [--delrepo] repoUrl sourceDirectory [targetDirectory]

If targetDirectory is not specified it will be set to sourceDirectory.
Downloads a sourceDirectory from a Git repository into targetdirectory.
If targetDirectory is not specified, a directory named after `basename sourceDirectory`
will be created under the current directory.

If --delrepo is specified then the .git subdirectory in the clone will be removed after cloning.


Example 1:
Clone the tree/master/django/conf/app_template directory from the master branch of
git@github.com:django/django.git into ./app_template:

\$ $(basename $0) git@github.com:django/django.git django/conf/app_template

\$ ls app_template/django/conf/app_template/
__init__.py-tpl  admin.py-tpl  apps.py-tpl  migrations  models.py-tpl  tests.py-tpl  views.py-tpl


Example 2:
Clone the django/conf/app_template directory from the master branch of
https://github.com/django/django/tree/master/django/conf/app_template into ~/test:

\$ $(basename $0) git@github.com:django/django.git django/conf/app_template ~/test

\$ ls test/django/conf/app_template/
__init__.py-tpl  admin.py-tpl  apps.py-tpl  migrations  models.py-tpl  tests.py-tpl  views.py-tpl

"
  exit 1
}

if [ -z "$1" ]; then help "Error: repoUrl was not specified.\n"; fi
if [ -z "$2" ]; then help "Error: sourceDirectory was not specified."; fi

if [ "$1" == --delrepo ]; then
  DEL_REPO=true
  shift
fi

REPO_URL="$1"
SOURCE_DIRECTORY="$2"
if [ "$3" ]; then
  TARGET_DIRECTORY="$3"
else
  TARGET_DIRECTORY="$(basename $2)"
fi

echo "Cloning into $TARGET_DIRECTORY"
mkdir -p "$TARGET_DIRECTORY"
cd "$TARGET_DIRECTORY"
git init
git remote add origin -f "$REPO_URL"
git config core.sparseCheckout true

echo "$SOURCE_DIRECTORY" > .git/info/sparse-checkout
git pull --depth=1 origin master

if [ "$DEL_REPO" ]; then rm -rf .git; fi

Patrick Simard · Answer 20 · 2020-04-23T17:45:36.543

So i tried everything in this tread and nothing worked for me ... Turns out that on version 2.24 of Git (the one that comes with cpanel at the time of this answer), you don't need to do this

echo "wpm/*" >> .git/info/sparse-checkout

all you need is the folder name

wpm/*

So in short you do this

git config core.sparsecheckout true

you then edit the .git/info/sparse-checkout and add the folder names (one per line) with /* at the end to get subfolders and files

wpm/*

Save and run the checkout command

git checkout master

The result was the expected folder from my repo and nothing else Upvote if this worked for you

How do I clone a subdirectory only of a Git repository?

20 Answers20

Filter branch

Sparse checkout

coSubDir.sh

Linked

Related