Import existing source code to GitHub

How can I import source code from my computer to my GitHub account?

  • git list remote branches, order by number of commits
  • Permission Denied (publickey) - Git Bash on Windows
  • MongoDB database on git repository
  • GIT can't pull: failed to symlink 'path/filename': File name too long
  • Smartest way to grab a file from GitHub via REST API or Ocktokit (Ruby)
  • Why does 'SCM Status' break when file system is irregular?
  • How to exclude files for pushing
  • how to make branches identical
  • Prevent users from doing git commit -a
  • how to git log with date-time and file names in one line
  • Using RStudio to Make Pull Requests in Git
  • Gitignore exclude certain files in all subdirectories
  • 13 Solutions collect form web for “Import existing source code to GitHub”

    If you’ve got local source code you want to add to a new remote new git repository without ‘cloning’ the remote first, do the following (I often do this – you create your remote empty repository in bitbucket/github, then push up your source)

    1. Create the remote repository, and get the URL such as or

      If your local GIT repo is already set up, skips steps 2 and 3

    2. Locally, at the root directory of your source, git init

      2a. If you initialize the repo with a .gitignore and a you should do a git pull {url from step 1} to ensure you don’t commit files to source that you want to ignore 😉

    3. Locally, add and commit what you want in your initial repo (for everything, git add . then git commit -m 'initial commit comment')

    4. to attach your remote repo with the name ‘origin’ (like cloning would do)
      git remote add origin [URL From Step 1]

    5. Execute git pull origin master to pull the remote branch so that they are in sync.
    6. to push up your master branch (change master to something else for a different branch):
      git push origin master

    This is explained in the excellent free eBook ProGit. It assumes you already have a local Git repository and a remote one. To connect them use:

    $ git remote
    $ git remote add pb git://
    $ git remote -v
    origin    git://
    pb    git://

    To push the data from the local repository to GitHub use:

    $ git push pb master

    If you have not setup a local and/or a remote repository yet, check out the help on GitHub and the previous chapters in the book.

    One of the comments mentioned using the GitHub GUI, but it didn’t give any specific help on using and notice that most if not all the answers were useful at the command prompt only.

    If you want to use the GitHub GUI, you can follow these steps:

    1. Click the “+” button and choose “Add Local Repository”
      Enter image description here
    2. Navigate to the directory with your existing code and click the “Add” button.
    3. You should now be prompted to “Create a new local Git repository here” so click the “Yes” button.
      Enter image description here
    4. Add your “Commit Summary” and “Extended description” as desired. By default, all of your files should selected with checkmarks already. Click the “Commit & Sync” button.
      Enter image description here
    5. Now you will be prompted to add the name and description of your project as well as which account to push it to (if you have multiple). Click the “Push Repository” button
      Enter image description here

    After a moment with a spinning GitHub icon, your source code will belong to a local repository and pushed/synchronised with a remote repository on your GitHub account. All of this is presuming you’ve previously set up the GitHub GUI, your GitHub account, and SSH keys.

    As JB quite rightly points out, it’s made incredibly easy on GitHub by simply following the instructions.

    Here’s an example of the instructions displayed after setting up a new repository on GitHub using when you’re logged in.

    Global setup:
     Set up Git:
      git config --global "Name"
      git config --global
    Next steps:
      mkdir audioscripts
      cd audioscripts
      git init
      touch README
      git add README
      git commit -m 'first commit'
      git remote add origin
      git push -u origin master
    Existing Git repository?
      cd existing_git_repo
      git remote add origin
      git push -u origin master
    Importing a Subversion repository?
      Check out the guide for step-by-step instructions.

    It couldn’t be easier!!

    Yes. Create a new repository, doing a git init in the directory where the source currently exists.

    More here:

    1. Open your GitHub dashboard (it’s at if you’re logged in)
    2. Click on New Repository
    3. Fill in the blanks; click on Create Repository
    4. Follow instructions on the page that appears then

    I had a bit of trouble with merging when trying to do Pete’s steps. These are the steps I ended up with.

    1. Use your OS to delete the .git folder inside of the project folder that you want to commit. This will give you a clean slate to work with. This is also a good time to make a .gitignore file inside the project folder. This can be a copy of the .gitignore created when you created the repository on Doing this copy will avoid deleting it when you update the repository.

    2. Open Git Bash and navigate to the folder you just deleted the .git folder from.

    3. Run git init. This sets up a local repository in the folder you’re in.

    4. Run git remote add [alias][gitUserName]/[RepoName].git. [alias] can be anything you want. The [alias] is meant to tie to the local repository, so the machine name works well for an [alias]. The URL can be found on, along the top ensure that the HTTP button out of HTTP|SSH|Git Read-Only is clicked. The git:// URL didn’t work for me.

    5. Run git pull [alias] master. This will update your local repository and avoid some merging conflicts.

    6. Run git add .

    7. Run git commit -m 'first code commit'

    8. Run git push [alias] master

    From Bitbucket:

    Push up an existing repository. You already have a Git repository on your computer. Let’s push it up to Bitbucket:

    cd /path/to/my/repo
    git remote add origin ssh://
    git push -u origin --all   # To push up the repo for the first time

    I came here looking for a simple way to add existing source files to a GitHub repository. I saw @Pete’s excellently complete answer and thought “What?! There must be a simpler way.”

    Here’s that simpler way in five steps (no console action required!)

    If you’re really in a hurry, you can just read step 3. The others are only there for completeness.

    1. Create a repository on the GitHub website. (I won’t insult your intelligence by taking you through this step-by-step.)
    2. Clone the new repository locally. (You can do this either through the website or through desktop client software.)
    3. Find the newly cloned repository on your hard drive and add files just like you would to a normal directory.
    4. Sync the changes back up to GitHub.
    5. That’s it!


    Add a GitHub repository as remote origin (replace [] with your URL):

    git remote add origin []

    Switch to your master branch and copy it to develop branch:

    git checkout master
    git checkout -b develop

    Push your develop branch to the GitHub develop branch (-f means force):

    git push -f origin develop:develop

    Here are some instructions on how to initiate a GitHub repository and then push code you’ve already created to it. The first set of instructions are directly from GitHub.


    1. In the upper-right corner of any page, click, and then click New repository.

    2. Create a short, memorable name for your repository. For example, “hello-world”.

    3. Optionally, add a description of your repository. For example, “My first repository on GitHub.”

    4. Choose between creating a public or private repository.

    5. Initialize this repository with a README.

    6. Create repository.

    Congratulations! You’ve successfully created your first repository, and initialized it with a README file.

    Now after these steps you will want to push the code on your local computer up to the repository you just created and you do this following these steps:

    1. git init (in the root folder where your code is located)

    2. git add -A (this will add all the files and folders in your directory to be committed)

    3. git commit -am "First Project commit"

    4. git remote add origin (you’ll find this address on the GitHub repository you just created under “ssh clone URL” on the main page)

    5. git push -u origin master

    That’s it. Your code will now be pushed up to GitHub. Now every time you want to keep pushing code that has changed just do.

    1. git commit -m "New changes"

    2. git push origin master (if master is the branch you are working on)

    Actually, if you opt for creating an empty repo on GitHub it gives you exact instructions that you can almost copy and paste into your terminal which are (at this point in time):

    …or create a new repository on the command line
    echo "# ..." >>
    git init
    git add
    git commit -m "first commit"
    git remote add origin<user>/<repo>.git
    git push -u origin master

    Solution for me:

    The problem is the size of a file, which cannot exceed 100M.

    Before migrating to github, in the repository do this:

    git clone --mirror git://
    mv bfg-1.12.12.jar bfg.jar
    java -jar bfg.jar --strip-blobs-bigger-than 100M some-big-repo.git
    cd some-big-repo.git
    git reflog expire --expire=now --all && git gc --prune=now --aggressive
    git push


    Now make the migration again by the tool:

    see more:
    Error while pushing to github repo

    I hope I helped you. 🙂

    Git Baby is a git and github fan, let's start git clone.