
In his story “The Library of Babel,” Argentine writer and librarian Jorge Luis Borges detailed a possibly infinite library that contains a superabundance of books. The trouble is that there is no order to this vast amount of information, so — ironically — the books are rendered effectively useless to those readers searching for knowledge, and the librarians are left in a state of intense despair. 

In our everyday life, we are likely familiar with well organized libraries in our communities, and may be quite adept at using search engines to find information online. When it comes to information outside of textual data — like searching for the code that runs software — there are still opportunities for innovation and improved indexing. While programmers may be well served through reading and learning from repositories of software they know and can access, they may be unable to search code they don’t yet know about or search across large and multiple code bases. Without the ability to meaningfully search code to understand how programs work, and to build on these past efforts towards more powerful software, the ability for developers to continually innovate may have diminishing returns.

Fortunately, humans have been working on indexing and searching across stores of knowledge for a long time — and how to address Borges’s infinite library — even in terms of software. Here, we’ll discuss a brief history of indexing and search across written data, and then consider the recent advances in code search from the last several decades. As we continue to make advances in code indexing and search, more people will have the access needed to effectively understand and create technology, and emerging and expert developers alike will be able to learn from existing code and, in turn, contribute code in service to their communities. 

## Analog and digital search

Across the written record, people have developed ways to find relevant information beginning with tables of contents two millennia ago, alphabetized topics or concordances in the 5th century, and the book index in the 13th century. Physical libraries, too, have a long history of information architecture to support the retrieval of relevant knowledge: in the 16th century, Swiss Polymath Konrad Gessner used paper slips to organize topics; the mid-19th century saw the introduction of ledger books; and by the 1870s physical card catalogs became commonplace in the United States and Britain. 

Analog knowledge indexing has paved the way for digital search engines that we use to rapidly search across websites and media today. As we continue to create, document, and share knowledge, we need to be able to continue to search for and find knowledge that is relevant to us from an ever-increasing volume of information, so that we too can participate in knowledge production. 

## Searching code, the beginnings

Like textual information, computer code is a site where information is stored. As more software is developed and code is created, we need to innovate the way we search for and retrieve code so that we can participate effectively in understanding and creating technology. Tools to search computer code and digital file systems have been developed alongside innovations in technology. 

Bell Labs was an early pioneer in text-based computer search, being the institution behind both `grep` and Cscope. In 1973, Ken Thompson wrote the command-line utility `grep`, which is a tool that allows users to search plain-text data sets for lines that match a given regular expression. The first formation of the tool was developed in order to support Lee E. McMahon’s research project of determining authorship of individual texts within the Federalist Papers via statistical language analysis, and was originally written by Thompson in PDP-11 assembly language. While `grep` has implications across all digital text search, and is not limited to code search, it is an important building block of later tools designed specifically to search code bases.

By the 1980s, Bell Labs had a large C codebase and Joe Steffen began writing a tool that would later be called Cscope in order to aid his own work. Beginning with shell scripts of `grep` and `sed` commands, Cscope eventually would become a C program with a graphical user interface. Because it led to such an increase in productivity across the computation teams at Bell Labs, Cscope was brought into the official AT&T Unix distribution.

## Searching within operating systems

Today, we are accustomed to being able to search within our graphical operating systems and to find lines of code in our IDEs, but these everyday experiences were not always possible. 

In 1991, Microsoft was working on a technology project with the code name Cairo, predating Windows 95. Within the Cairo operating system was a piece of technology called the Object File System, which would later become known as WinFS. The Object File System organized the data within the filesystem into a collection of objects in a strongly typed schema, providing a human readable interface so that users could search across files. Over time, this project became the backbone of file indexing and search within Windows, doing much of the backend work for users to be able to find files effectively. The Object File System also offered developers the ability to hook into this functionality via APIs.

Linux, too, would benefit from search innovation as early as 1994. Two Norwegian students by the names of Arne Georg Gleditsch and Per Kristian Gjermshus were learning about Linux architecture when they began writing a program to display Linux files through a web browser so that they could click on variables and inspect how they were used. As they understood that others working on the Linux kernel were also interested in this project, they posted it on SourceForge early in their development process to support collaboration. Today’s stable version of LXR — or Linux Cross-Referencer — indexes source code and provides code comprehension through web-based browsing of code. This provides definition and usage links to any identifier within the code base. LXR is such a popular tool because Linux enjoys a high number of contributors who need to familiarize themselves with the codebase quickly. 

## Innovating on search

As search tools advanced, implementations continued to be built on top of existing tools. Expanding on `grep`, [agrep](https://github.com/Wikinaut/agrep) added fuzzy search — or _approximate_ matches — to text string- and regex-matching search (hence, “approximate” `grep`). The agrep tool was developed between 1988 and 1991 by Sun Wu and Udi Manber at the University of Arizona. Implementing the methods provided by the Levenshtein algorithm to search text files, agrep interprets relatively simple patterns, but its benefits over `grep` are that it can find similar terms and is often faster. 

Extending on approximate matching and developed by Ville Laurikari, [TRE](https://laurikari.net/tre/) is a command line search tool that offers greater functionality including allowing full regexps of any length, which can be used on Linux via the `tre-agrep` command. The work done on agrep served as a crucial foundation for GLIMPSE (GLobal IMPlicit SEarch), a tool for searching through entire file systems and first [described in a paper](https://www.usenix.org/conference/usenix-winter-1994-technical-conference/glimpse-tool-search-through-entire-file-systems) published in 1994 by Manber and Wu. From GLIMPSE, [Webglimpse](https://web.archive.org/web/20191001112623/http://webglimpse.net/) was developed, which provided developers with a way to add search capability to their web projects.

In the 2000s, Mozilla created a [cross reference tool](https://web.archive.org/web/20080513070520/http://mxr.mozilla.org/) to display and search Mozilla source code built from a fork of LXR with free-text search implemented using GLIMPSE. This search tool was first called MXR (Mozilla Cross Reference), later DXR (Dehydra Cross Reference), and is currently operative as [Searchfox](https://searchfox.org/). Initially written for code navigation across C++ and JavaScript, today it also supports Rust. 

Many search tools would eventually extend the functionality of Apache Lucene, an open-source search engine library originally written in Java by Doug Cutting in 1999. Providing functionality to implement internet search engines as well as local search, Lucene offers approximate search and can be used to generate recommendations as well. The enterprise search server Elasticsearch is notably built off of Lucene, and both [GitHub](https://www.elastic.co/customers/github) and [GitLab](https://about.gitlab.com/blog/2019/03/20/enabling-global-search-elasticsearch-gitlab-com/) use Elasticsearch to enable code search across their code host platforms. 

Also built on Apache Lucene is [OpenGrok](https://oracle.github.io/opengrok/), which is an open-source project written in Java and maintained by Oracle. Originally developed by [Chandan B.N.](https://github.com/oracle/opengrok/wiki/Story-of-OpenGrok), OpenGrok offers fast code search as well as a cross reference engine allowing developers to navigate their source tree. OpenGrok is very popular and actively maintained today. 

## The future of code search 

There are many code search efforts today in active development that gesture toward what developers may expect from code search in the future. Some of these include closed source tools like Google’s internal search tool, making its large code base more accessible to those working on it. The work on Google’s code search began with gsearch by Jeff Dean in the early 2000s, which offered a productivity boost for developers and made large-scale refactoring easier. In 2010, Steve Yegge led the development of Grok at Google for code comprehension; a version of Grok was eventually open-sourced as Kythe in 2015 and is actively under development. Google Code Search, led by Russ Cox, was a free beta public product that debuted in Google Labs in 2006 but was shut down in 2011. There currently is a [publicly re-released](https://cs.opensource.google/) version that debuted in 2020 for use exclusively with Google open source software and Google Cloud Source Repositories.

Founded in 2013 by Quinn Slack and Beyang Liu, Sourcegraph is open core software that offers universal code search across large code bases. Currently used by many enterprise companies as on-premises software, Sourcegraph is also available as [Sourcegraph cloud](https://sourcegraph.com), which enables developers to search across many publicly indexed open source repositories. Sourcegraph’s [long-term mission](https://handbook.sourcegraph.com/strategy-goals/strategy) is to help more people code, and, as we have seen with indexing books, being able to search across code can help more people understand others’ code and write their own code more effectively. 

There is continued interest in the code search space. GitHub, the popular code hosting platform that is a part of Microsoft, announced at the end of 2021 that it was developing improved code search capabilities. Their intention is to improve developer productivity. Investors are also interested in the value that code search can bring. Mintlify, co-founded by Hahnbee Lee and Han Wang, raised a pre-seed round in 2022 and offers a “search engine in your code base” through leveraging AI to help developers search code.

As the number of code repositories increasingly resembles Borges’s infinite library, it is more apparent that we need to be able to meaningfully search across this form of knowledge, just as we do with any other text. User-friendly, sophisticated code search and indexing can allow developers to innovate effectively, learn from and build off of existing code libraries, and quickly onboard onto existing software projects. Ultimately, being able to search code and search it well enables more people to build software through increased coding literacy and access to knowledge. 


Code search history

A history of code search, from libraries to Google, Sourcegraph, and GitHub

A short history of code search


Sourcegraph is actively working to index open source software so that developers can search all of the code that they care about. Being able to search across public repositories can help you learn open source best practices, inspect the libraries you may have as dependencies on your projects, and provide you with real-world examples you can leverage while you’re programming.

This tutorial will guide you through how to add public, open source repositories from GitHub and GitLab to Sourcegraph so that these code bases are indexed by the platform. Once you have added and synched these public repositories, anyone using Sourcegraph Cloud will be able to see results from these projects when they search all the code that is available through Sourcegraph via its global context.

To add public repositories to Sourcegraph, you’ll need a free Sourcegraph account, which you can set up by following our documentation on [getting started with Sourcegraph](https://docs.sourcegraph.com/getting-started#how-do-i-start-using-sourcegraph).

## Step 1 — Access user settings

Log into [Sourcegraph.com](https://sourcegraph.com) and click on your user icon on the top right corner of the page.

A drop-down menu will be displayed. From here, click on **Settings**.

![Sourcegraph home with user menu](https://storage.googleapis.com/sourcegraph-assets/learn/tutorial-images/sourcegraph-home-user-menu.png)

You’ll be taken to a page that indicates that you are in your settings with a header of **User Settings** displayed towards the top of the page, and a panel with options regarding your user account on the left hand side of the window.

## Step 2 — Add repositories

From the panel on the left hand side of the interface, you can click on **Repositories** in order to be taken to the page where you can manage repositories. If you already have repositories added, you’ll need to click on the **Manage Repositories** button that is on this page in order to access this page.

![Sourcegraph manage repositories page](https://storage.googleapis.com/sourcegraph-assets/learn/tutorial-images/sourcegraph-manage-repositories.png)

Within the **Manage Repositories** page, you’ll be presented with a few options:

- In the **Your repositories** section, you can sync _your own_ public repositories using GitHub or GitLab.
- In the **Other public repositories** section, you can add any public repositories on GitHub and GitLab.

For now, we’ll focus on the second option, and click the checkbox next to `Sync specific public repositories by URL`. Choosing this option, you can add any public repositories of code from either GitHub or GitLab, whether you contribute to the project or not.

Once you have clicked the checkbox, a check mark sign will appear in the box, like so: &#9745;. At this point, a box will display, similar to the screenshot below.

![Sourcegraph other public repositories list](https://storage.googleapis.com/sourcegraph-assets/learn/tutorial-images/sourcegraph-other-public-repositories.png)

Within the box, you can type URLs of the public open source projects that you care about, one per line, with no separating characters other than the `ENTER` key.

The example above indexed the following two repositories, but you should choose repositories that are important to you, as these are already indexed:

- [github.com/prisma/women-world-wide](https://github.com/prisma/women-world-wide)
- [github.com/do-community/cloud_haiku](https://github.com/do-community/cloud_haiku)

When you are satisfied with the repositories that we have added for now (you can always add more later), you can click the **Save** button below.

## Step 3 — Search the repositories you added

At this point, you’re able to search the public repositories that you added. To verify this, you can scroll up to the top of the page where the Sourcegraph search bar is. To the left of the search bar it states `context:global`, which you can click on to limit it to your own username, to search the repositories you have added.

![Sourcegraph search with global context](https://storage.googleapis.com/sourcegraph-assets/learn/tutorial-images/sourcegraph-context.png)

From here, you can search a common keyword to ensure that the public code you added is available to you.

To ensure that the public code you just added is available to anyone using Sourcegraph (even those not logged in), you can open a new private or incognito window and search for a fairly unique string to the code bases you have just added. In this case, we’ll search for `women world wide` to ensure that the `prisma/women-world-wide` repository is indexed:

<SourcegraphSearch query="women world wide"/>

![Sourcegraph verification of OSS added](https://storage.googleapis.com/sourcegraph-assets/learn/tutorial-images/sourcegraph-anonymous-verification.png)

The screenshot above reveals output from the repository we just added to an anonymous user who is not logged in, which indicates that we have successfully added this public repository to Sourcegraph.

## Next steps

From here, you may want to sync your GitHub or GitLab account to add your own public repositories or forks.

With open source projects that are important to you fully indexed by Sourcegraph, you will be able to use libraries and other dependencies more effectively, and be able to summon up effective examples quickly while you’re building.


Learn how to add public, open source repositories to Sourcegraph.

How to add open source software projects to Sourcegraph Cloud


Sourcegraph is a universal code search tool that can help you search all the code that is meaningful to you, whether that code is public and open source, or private to you or your team. 

---
**NOTE**:

_Searching private code is currently in Public Beta._

---

This tutorial will guide you through adding private repositories from a code host to Sourcegraph Cloud so that you can search within and across your private code. 

**Your security and privacy are very important to Sourcegraph; Sourcegraph will have no access to see your private code and will never sell your private code. Only _you_ and your teammates with access to a given private repository via your code host will be able to see the private code you have added to Sourcegraph.**

To add your private repositories to Sourcegraph, you’ll need a free Sourcegraph account, which you can set up by following our documentation on [getting started with Sourcegraph](https://docs.sourcegraph.com/getting-started#how-do-i-start-using-sourcegraph).

## Step 1 — Access user settings

Log into [Sourcegraph.com](https://sourcegraph.com) and click on your user icon on the top right corner of the page. 

A drop-down menu will be displayed. From here, click on **Settings**.

![Sourcegraph home with user menu](https://storage.googleapis.com/sourcegraph-assets/learn/tutorial-images/sourcegraph-home-user-menu.png)


You’ll be taken to a page that indicates that you are in your settings with a header of **User Settings** displayed towards the top of the page, and a panel with options regarding your user account on the left hand side of the window.

## Step 2 — Add private repositories

From the panel on the left hand side of the interface, you can click on **Repositories** in order to be taken to the page where you can manage repositories. If you already have repositories added, you’ll need to click on the **Manage Repositories** button in order to access this page.

![Sourcegraph repositories section under settings](https://storage.googleapis.com/sourcegraph-assets/learn/tutorial-images/sourcegraph-repositories-section.png)


If you have no repositories yet, click on **+ Add repositories**. You’ll be presented with the option to connect with a code host in the **Your repositories** section. Here, you can sync _your_ repositories using GitHub or GitLab. This will include both your public repositories and your private repositories.

We’ll focus on adding private repositories. Click the `Connect code hosts` link and add GitHub, GitLab or both in order to connect with your software repositories.

Once connected, you’ll be able to sync all of your repositories or selected ones. You’ll be presented with a display of the repositories you have access to via your codehost, and will be able to click on the checkboxes to the left of their names in order to add them to Sourcegraph.

Depending on the code repositories you have access to, you may receive a list of both private and public repos. The ones that are private will be labeled with a `Private` tag to the right of the repository name. 

If you are part of an organization on a code host, an administrator will need to grant you access to private repositories there. For more information about this, please review our [troubleshooting guidance](https://docs.sourcegraph.com/code_search/how-to/adding_repositories_to_cloud#troubleshooting). 

In the image below, the `medieval-data` repository is a private repository, as indicated by the `Private` label.

![Sourcegraph repo list showing private label](https://storage.googleapis.com/sourcegraph-assets/learn/tutorial-images/sourcegraph-repo-list-private-label.png)

You can also search for repositories by name, using the search bar labeled `Search repositories…`. 

Click the checkbox next to the private repositories you would like to add. In the image above, the `medieval-data` repository represents a checked checkbox. Next, scroll down to press the `Save` button at the bottom of the page. 

Once Sourcegraph has fully saved your selections, you should receive an output page that confirms all of the repositories you have saved to your account, both public and private.

![Sourcegraph list displaying all saved repos](https://storage.googleapis.com/sourcegraph-assets/learn/tutorial-images/sourcegraph-list-of-saved-repos.png)

The image above shows 2 private repositories labeled with the `Private` tag and 5 public open source repositories that were also saved. For guidance on how to add open source software to Sourcegraph, review our tutorial, [How To Add Open Source Software Projects to Sourcegraph](https://learn.sourcegraph.com/how-to-add-open-source-software-projects-to-sourcegraph).

## Step 3 — Search your private repositories

At this point, you’re able to search all the private repositories you have access to that you added. To verify this, you can scroll up to the top of the page where the Sourcegraph search bar is. To the left of the search bar it states `context:global`. Instead, click on your own username (`@your-username`) to limit the search to your own repositories. 

![Sourcegraph search with context choice](https://storage.googleapis.com/sourcegraph-assets/learn/tutorial-images/sourcegraph-context.png)

Next, further limit the context down so that you are only searching your private repositories. You can do this with the `visibility` command set to `private`. 

Let’s perform a search for the term `html` with the context set to our own username, and the command `visibility:private`.

![Sourcegraph visibility private code search](https://storage.googleapis.com/sourcegraph-assets/learn/tutorial-images/sourcegraph-visibility-private-code-search.png)

The screenshot above reveals 15 results across the private repositories loaded into this Sourcegraph account.

You can perform a search similar to the one above with the Sourcegraph box below. Make sure you change the context to your own username:

<SourcegraphSearch query="visibility:private html"/>

Running a command like the one above across your own username will enable you to search across all of the private repositories that you have access to, providing you with all the benefits of universal code search.

## Next steps

You should now be able to search your private code in Sourcegraph Cloud, a feature that is currently in public beta! If you had any issues in bringing in repositories, please review our [troubleshooting guidance](https://docs.sourcegraph.com/code_search/how-to/adding_repositories_to_cloud#troubleshooting). Note that organizations you are affiliated with will need to grant you relevant access. 

With your private code connected to Sourcegraph, you can learn more about how to search effectively by following along with our [Sourcegraph search series](https://learn.sourcegraph.com/how-to-search-code-with-sourcegraph-using-literal-patterns). You can also learn more about the product through reviewing Sourcegraph’s [product documentation](https://docs.sourcegraph.com/). 

For a video version of this tutorial, check out "[How to add private code repositories to Sourcegraph Cloud (video)](/how-to-add-private-code-repositories-to-sourcegraph-video)."

Adding private software repos to Sourcegraph Cloud

Learn how to add private software repositories to Sourcegraph.

How to add private code repositories to Sourcegraph Cloud


With a self-hosted instance of Sourcegraph, you can search your local code, and the code that you and your team collaborate on in repositories held within code hosts like GitHub and GitLab. 

In order to use a self-hosted instance of Sourcegraph, you’ll need to create an account. This tutorial will provide you with guidance on creating an account with Sourcegraph.

## Prerequisites

Before setting up an account on a self-hosted instance of Sourcegraph, you will need to set up your own instance of Sourcegraph, or be invited to join one. 

If you need to install and set up an instance of Sourcegraph, you can review our [installation guides on Sourcegraph Learn](https://learn.sourcegraph.com/tags/installation), or read through our [documentation on installation](https://docs.sourcegraph.com/admin/install). 

With access to a Sourcegraph instance, you can get started.

## Step 1 — Navigate to the URL of your instance of Sourcegraph

If you are invited to use an instance of Sourcegraph, ask an administrator to create an account for you, or set up a sign on process to access the instance.

If you have just set up your own instance of Sourcegraph, you should have received output on your terminal for the relevant IP address and port created to access Sourcegraph.

![Sourcegraph terminal output after installation](https://storage.googleapis.com/sourcegraph-assets/learn/tutorial-images/sourcegraph-logo-terminal.png)

<Highlighter
input='Sourcegraph is ready at: http://the-server-ip-address:7080'
matcher='the-server-ip-address'
/>

Using your preferred browser, navigate to the relevant IP address or URL. At this point, you should be at the signup screen if you have not made an account already.

## Step 2 — Sign up with your email address

Once you have navigated to the IP address or URL of your Sourcegraph instance, you should be at the signup page if you don’t already have an account. 

![Sourcegraph self-hosted instance login page](https://storage.googleapis.com/sourcegraph-assets/learn/tutorial-images/sourcegraph-login-page.png)

From this page, you’ll be able to sign up with your email address, then create a username and password. 

Note that if you have navigated to a Sourcegraph instance that you were not invited to, you will receive this page and will need to contact the administrator of the relevant instance.

![Sourcegraph instance login, need to contact site administrator if you don’t get the signup page](https://storage.googleapis.com/sourcegraph-assets/learn/tutorial-images/sourcegraph-contact-site-admin.png)

You will need to use a valid email address that you can access. If you use an invalid email address, you will receive a descriptive error message to troubleshoot your account creation. Enter your email address in the **Email** field of the signup form. 

Once your email address is accepted, you can choose your preferred username in the form input section labeled **Username**. Only alphanumeric characters are permitted within the username.

Next, create a password. A password adds a layer of security to your account by preventing unauthorized access. Your chosen password should be at least 12 characters. Enter a secure password in the form input section labeled **Password**, and make a note of it.

After filling the form with a valid email address, username, and password, click on the button at the bottom of the form to create an account and continue.

## Step 3 — Verify that your account was created

Once you have created your account successfully, you will be taken to your account overview page. 

![Sourcegraph overview page after account creation](https://storage.googleapis.com/sourcegraph-assets/learn/tutorial-images/sourcegraph-overview-page-after-account-creation.png)

From here, you can begin completing the onboarding process by adding repositories, searching your code, finding some references, and configuring SSO or adding teammates. You can review all of our [administration documentation](https://docs.sourcegraph.com/admin) to learn more.

## Next steps

Now that you have created a Sourcegraph account, you can start searching the code that is important to you.

For some introductory tips, check out our video on the [three ways to search with Sourcegraph](https://learn.sourcegraph.com/three-ways-to-search-code-with-sourcegraph). You can also review all of our [search tutorials](https://learn.sourcegraph.com/tags/search).

If you have installed your instance of Sourcegraph and created an account, and want to upgrade to an enterprise version to allow your team to use more advanced code search features, you can look at our [enterprise getting started guide](https://docs.sourcegraph.com/adopt/enterprise_getting_started_guide) to help you begin.


Search your code with a Sourcegraph account

Create an account on self-hosted Sourcegraph to your code

How to create a self-hosted Sourcegraph account


Sourcegraph Cloud lets you search across open source software and your private repositories hosted on GitHub or GitLab in a web browser. To begin using Sourcegraph Cloud, you can navigate directly to [sourcegraph.com](https://sourcegraph.com) and begin searching the code that Sourcegraph has already indexed. If you would like to save your search history or to connect your public or private repositories on GitHub or GitLab, you will need to create a Sourcegraph Cloud account.

**_Note that searching private code on Sourcegraph Cloud is currently in Public Beta._**

There are three ways to sign up for a Sourcegraph Cloud account, which will be detailed in the sections below. Feel free to skip ahead to your preferred method of signing up:

* [Creating a Sourcegraph Cloud account with GitHub](#creating-a-sourcegraph-cloud-account-with-github)
* [Creating a Sourcegraph Cloud account with GitLab](#creating-a-sourcegraph-cloud-account-with-gitlab)
* [Creating a Sourcegraph Cloud account with an email address](#creating-a-sourcegraph-cloud-account-with-an-email-address)

Open your browser of choice, and we can get started.

## Navigate to the Sourcegraph Cloud sign up page

In your browser address bar, type in [sourcegraph.com](https://sourcegraph.com). When the page is fully loaded, you’ll receive a page similar to the following, with Sourcegraph’s logo and a search bar.

![Sourcegraph Cloud homepage](https://storage.googleapis.com/sourcegraph-assets/learn/tutorial-images/sourcegraph-cloud-landing.png)

On the right-hand side of the top navigation pane, there is a **Sign up** button that takes you to the [account creation](https://sourcegraph.com/sign-up) page. The **Sign up** page is where you can create an account.

![Sourcegraph Cloud signup page](https://storage.googleapis.com/sourcegraph-assets/learn/tutorial-images/sourcegraph-cloud-signup-landing.png)

From here, you can continue to signing up through your option of choice.

## Creating a Sourcegraph Cloud account with GitHub

To use GitHub authentication, from the **[Sign up](https://sourcegraph.com/sign-up)** page, click on the **Continue with GitHub** button. Clicking on the GitHub button will take you to GitHub’s login page if you are not already logged in.

![Create a Sourcegraph Cloud with GitHub](https://storage.googleapis.com/sourcegraph-assets/learn/tutorial-images/github-login-to-access-sourcegraph.png)

Once you are logged into GitHub, you will be directed to a page that requires you to authorize Sourcegraph. The authorization you will be giving to Sourcegraph will allow Sourcegraph to access the GitHub details mentioned in the signup form for your account creation. 

![Authorize Sourcegraph Cloud with GitHub](https://storage.googleapis.com/sourcegraph-assets/learn/tutorial-images/authorise-sourcegraph-on-github.png)

If you choose to authorize Sourcegraph, you will be redirected to Sourcegraph Cloud’s welcome page. By completing these steps, you have successfully created a Sourcegraph Cloud account using GitHub.

## Creating a Sourcegraph Cloud account with GitLab

If you have a GitLab account and would prefer to create a Sourcegraph account that is tied to your GitLab account, click on the **GitLab** button on Sourcegraph Cloud’s **[Sign up](https://sourcegraph.com/sign-up)** page.

If you are not signed into your GitLab account, you will be redirected to log into GitLab to continue.

![Login to GitLab](https://storage.googleapis.com/sourcegraph-assets/learn/tutorial-images/gitlab-login.png)

If you are logged into GitLab, you will need to login so that you can authorize GitLab as the method to create a Sourcegraph Cloud account.

![Authorize Sourcegraph Cloud with GitLab](https://storage.googleapis.com/sourcegraph-assets/learn/tutorial-images/authorize-sourcegraph-on-gitlab.png)

Clicking on **Authorize** will allow Sourcegraph to have access to the GitLab details that are mentioned in the signup form for your account creation.

If you choose to authorize Sourcegraph, you will be redirected to Sourcegraph Cloud’s welcome page. By completing these steps, you have successfully created a Sourcegraph Cloud account using GitLab.

## Creating a Sourcegraph Cloud account with an email address

To create a Sourcegraph account by providing an email address, you will need to use a valid address that you can access. 

On the **[Sign up](https://sourcegraph.com/sign-up)** page, there is a [continue with email](https://sourcegraph.com/sign-up?showEmail=true) link below the code host buttons. Clicking on this link takes you to a form where you can create an account using an email address. Enter the valid email address you would like to use in the form input space labeled **Email**.

![Sourcegraph Cloud signup with email form](https://storage.googleapis.com/sourcegraph-assets/learn/tutorial-images/sourcegraph-cloud-signup-email-field.png)

An invalid email address will throw an error message and will not let you complete the account creation process.

Each Sourcegraph username that is tied to an email address will need to be unique, as there are no two users with the same username on Sourcegraph Cloud.

Enter your preferred username in the form input section labeled **Username**.

![Sourcegraph Cloud valid username field with email signup](https://storage.googleapis.com/sourcegraph-assets/learn/tutorial-images/username-field-sourcegraph-signup-form.png)

If the username you have chosen is in use by another user, there will be an error that indicates that the username is taken. In this case, you can modify your preferred username to continue.

Next, create a password. A password lets you add a layer of security to your account by preventing unauthorized access.

When creating a Sourcegraph account, your chosen password should be at least 12 characters. Enter a secure password in the form input section labeled **Password**.

After completing the three steps above completely, you can click on the **Register** button to create an account. At this point, you will be taken to the welcome page of your account.

## Security on Sourcegraph Cloud

Your security and privacy are very important to Sourcegraph; Sourcegraph will have no access to see your private code and will never sell your private code. Only you and your teammates with access to a given private repository via your code host will be able to see the private code you have added to Sourcegraph.

Read more about Sourcegraph and privacy on our [privacy page](https://about.sourcegraph.com/privacy/).

## Next steps

Now that you have created a Sourcegraph Cloud account, you can start using Sourcegraph Cloud to search the code that is important to you by having a look at our [cheat sheet guide](/how-to-search-code-with-sourcegraph-a-cheat-sheet).

You may also want to check our video on the [three ways to search with Sourcegraph](/three-ways-to-search-code-with-sourcegraph) to learn the different ways you can use Sourcegraph to search your code.


Search code in a browser with a Sourcegraph Cloud account

Create a Sourcegraph Cloud account to search open source and private repos

How to create a Sourcegraph Cloud account


Sourcegraph is a tool that can allow you to search all the code that is important to you, from your own local repositories, to the software you build together with a team, to all the code that is available through open source projects. You can get started using Sourcegraph by using [Sourcegraph Cloud](https://sourcegraph.com/search) with your preferred web browser, or you may want to install your own instance of Sourcegraph locally or on a cloud server or virtual machine.

By installing Sourcegraph on your own hardware, you’ll be able to manage your own instance of Sourcegraph, providing you with complete control over who has access to your code. Your own installation will also allow you to connect your local (or server-side) code as well as any relevant Git servers. Git servers that you can connect to include GitHub, GitHub Enterprise, GitLab, Bitbucket, AWS CodeCommit, Perforce, and more.

We’ll go through how to install Sourcegraph on your local Linux machine with Docker so that you can begin to use Sourcegraph on all of your code. This installation guide is appropriate for local testing and should be quick to set up. If you would like to use Sourcegraph in a production environment, you should follow our documentation on installing Sourcegraph with [Docker Compose](https://docs.sourcegraph.com/admin/install/docker-compose) on a single node, or on a [Kubernetes cluster](https://docs.sourcegraph.com/admin/install/kubernetes).

## Step 1 — Install Docker

_If you already have Docker installed, you can [skip to the next step](#step-2--install-sourcegraph)._

On a Linux cloud server or local computer, you can install Docker via the command line as long as you are a user with super user privileges. We’ll go over how to install Docker across [Ubuntu and Debian](#ubuntu-and-debian), [Fedora](#fedora), and [CentOs](#centos) Linux distributions in this section. Skip down to the section that is relevant for the machine you’re using to install Sourcegraph.

### Ubuntu and Debian

Ensure that you have the [snap package manager](https://snapcraft.io/) installed by running the following commands in your terminal for **Ubuntu or Debian Linux**:

<PrismSyntaxHighlighter
input='sudo apt update
sudo apt install snapd
sudo snap install core'
language='bash'
/>

Once snap is fully installed, you can install Docker using snap.

<PrismSyntaxHighlighter
input='sudo snap install docker'
language='bash'
/>

Alternatively, you can install Docker through its packages available through the Docker installation page for [Ubuntu](https://docs.docker.com/engine/install/ubuntu/) or for [Debian](https://docs.docker.com/engine/install/debian/).

With Docker installed, you are ready to procceed to [Step 2](#step-2--install-sourcegraph).

### Fedora

If you are using **Fedora**, ensure that snap is installed by running the following command:

<PrismSyntaxHighlighter
input='sudo dnf install snapd'
language='bash'
/>

Once you confirm that snap is fully installed, you can install Docker using snap.

<PrismSyntaxHighlighter
input='sudo snap install docker'
language='bash'
/>

Alternatively, you can install Docker through its packages available through the [Docker installation page for Fedora](https://docs.docker.com/engine/install/fedora/).

With Docker installed, you are ready to procceed to [Step 2](#step-2--install-sourcegraph).

### CentOs

If you are using **CentOs**, you can ensure that snap is installed and ready by running the following commands. For more guidance on these commands, please visit snap’s [official documentation](https://snapcraft.io/install/docker/centos).

<PrismSyntaxHighlighter
input={`sudo yum install epel-release
sudo yum install snapd
sudo systemctl enable --now snapd.socket`}
language='bash'
/>

Once you confirm that snap is fully installed, you can install Docker using snap.

<PrismSyntaxHighlighter
input='sudo snap install docker'
language='bash'
/>

Alternatively, you can install Docker through its packages available through the [Docker installation page for CentOs](https://docs.docker.com/engine/install/centos/).

With Docker installed, you are ready to install Sourcegraph.

## Step 2 — Install Sourcegraph

Depending on the machine that you have, you’ll be able to run a Docker command to install Sourcegraph and get up and running with code search on your local repositories and beyond.

We’ll go over two approaches below; the first which is recommended for [Linux running on a local machine](#locally-on-linux), the second option is recommended for [Linux cloud servers](#on-a-linux-server).

### Locally on Linux

On local machines that use a Linux distribution, you’ll be able to install Sourcegraph by running the following Docker command.

<PrismSyntaxHighlighter
input='docker run --publish 7080:7080 \
--publish 127.0.0.1:3370:3370 \  
--rm --volume ~/.sourcegraph/config:/etc/sourcegraph \  
--volume ~/.sourcegraph/data:/var/opt/sourcegraph \  
sourcegraph/server:3.30.4'
language='bash'
/>

This command is telling your computer to install and run Sourcegraph in port 7080 of your localhost (127.0.0.1) and is calling up the relevant files from the Docker image of Sourcegraph. It is also setting up a store for your Sourcegraph data.

Once you run the command, you’ll receive some output indicating that Sourcegraph is getting set up. Sourcegraph will be ready when you receive the output similar to the following:

<Highlighter
input='✱ Sourcegraph is ready at: http://127.0.0.1:7080'
/>

At this point, you’ll be able to move onto the next section to verify your installation.

### On a Linux server

On a Linux cloud server, you can run the following command to keep your instance of Sourcegraph up and running even after you close your Terminal connection to the server.

<PrismSyntaxHighlighter
input='docker run -d --publish 80:7080 \
--publish 443:7443 \
--restart unless-stopped \
--volume /root/.sourcegraph/config:/etc/sourcegraph \
--volume /root/.sourcegraph/data:/var/opt/sourcegraph \
sourcegraph/server:3.30.4'
language='bash'
/>

This command is telling your server to install and run Sourcegraph in port 7080 of your server and is calling up the relevant files from the Docker image of Sourcegraph. It is also setting up a store for your Sourcegraph data.

Once you run the command, you’ll receive some output indicating that Sourcegraph is getting set up. Sourcegraph will be ready when you receive output similar to the following. Your server’s IP address will display in place of `your-server-ip-address`.

<Highlighter
input='✱ Sourcegraph is ready at: http://your-server-ip-address:7080'
matcher='your-server-ip-address'
/>

At this point, you’ll be able to move onto the next section to verify your installation.

## Step 3 — Verify the installation

When Sourcegraph is fully installed and ready to be used, the Sourcegraph logo will appear and you should access the URL that is indicated in the Terminal output.

![Installation complete verification on command line](https://storage.googleapis.com/sourcegraph-assets/learn/tutorial-images/sourcegraph-logo-terminal.png)

Open a browser and go to the URL indicated in the output. Keep in mind that if you are using a local machine, you’ll be directed to the localhost, but on a server you should go to the IP address of that server.

The first time you open Sourcegraph, the page that will be displayed will be the page to setup your administrative account.

![Sourcegraph create account and login page](https://storage.googleapis.com/sourcegraph-assets/learn/tutorial-images/sourcegraph-login-page.png)

You can create the account now. This account will be tied to your own instance of Sourcegraph.

Once you set up your account, you’ll be able to add repositories and set up your preferences and configuration.

## Next steps

Congratulations! You have installed Sourcegraph with Docker on your Linux machine and have created an account so that you can begin using Sourcegraph to search all of the code that is important to you.

If you have installed Sourcegraph on a Linux server rather than a local machine, you may want to secure your installation as a next step (to access Sourcegraph via `https` rather than `http`), which you can read more about through our official [Sourcegraph docs](https://docs.sourcegraph.com/admin/http_https_configuration#sourcegraph-single-instance-docker).

Once you have Sourcegraph up and running, and your code repositories available to Sourcegraph, you can check our overview video on the [three ways to search with Sourcegraph](/three-ways-to-search-code-with-sourcegraph) so that you can more effectively search your code.


Installing a self-hosted Sourcegraph test instance on Linux with Docker

Learn how to install Sourcegraph on your own machine with Docker

How to install Sourcegraph on Linux with Docker


Sourcegraph is a tool that can allow you to search all the code that is important to you, from your own local repositories, to the software you build together with a team, to all the code that is available through open source projects. You can get started using Sourcegraph by using [Sourcegraph Cloud](https://sourcegraph.com/search) with your preferred web browser, or you may want to install Sourcegraph locally or on a cloud server or virtual machine.

By installing Sourcegraph on your own hardware, you’ll be able to manage your own instance of Sourcegraph, providing you with complete control over who has access to your code. Your own installation will also allow you to connect your local (or server-side) code as well as any relevant Git servers. Git servers that you can connect to include GitHub, GitHub Enterprise, GitLab, Bitbucket, AWS CodeCommit, Perforce, and more.

We’ll go through how to install Sourcegraph on your local macOS machine with Docker so that you can begin to use Sourcegraph on all of your code. 

---
**NOTE**:

Sourcegraph does not provide support for machines with the Apple M1 chip. The below guidance provides suggestions for both Intel chips and M1 chips, but only the Intel chips are supported by Sourcegraph.

---

This installation guide is appropriate for local testing and should be quick to set up. If you would like to use Sourcegraph in a production environment, you should follow our documentation on installing Sourcegraph with [Docker Compose](https://docs.sourcegraph.com/admin/install/docker-compose) on a single node, or on a [Kubernetes cluster](https://docs.sourcegraph.com/admin/install/kubernetes).

## Step 1 — Install Docker

_If you already have Docker installed, you can [skip to the next step](#step-2--install-sourcegraph)._

On a macOS machine, you can install Docker from the [Docker installation page for Mac](https://docs.docker.com/docker-for-mac/install/). You’ll need to ensure that you are installing the right version for your machine’s respective chip.

You can determine what chip you have by navigating to the Apple menu in the top left corner of your screen, selecting `About This Mac` and reviewing what is displayed next to `Chip` in the window that appears.

Once you know which is the appropriate version to install, select either `Mac with Intel chip` for any macOS machine that is on an Intel chip, or `Mac with Apple chip` for any macOS machine that has an Apple M1 chip. Then follow the guidance from the Docker installation to complete the process.

With Docker fully installed, you’ll be ready to move onto the next section.

## Step 2 — Install Sourcegraph

Depending on the chip that you have, you’ll be able to run a Docker command to install Sourcegraph and get up and running with code search on your local repositories and beyond. 

The first section is for macOS machines with [Intel chips](#on-macos-with-intel-chip), and is currently the only macOS chip supported by Sourcegraph. The second option is a suggested workflow for macOS with [Apple M1 chips](#on-an-apple-m1-chip-on-macos), though this is not supported by Sourcegraph.

### On macOS with Intel chip

On local machines with an Intel chip, you’ll be able to install Sourcegraph by running the following Docker command.

<PrismSyntaxHighlighter
input='docker run --publish 7080:7080 \
--publish 127.0.0.1:3370:3370 \
--rm --volume ~/.sourcegraph/config:/etc/sourcegraph \
--volume ~/.sourcegraph/data:/var/opt/sourcegraph \
sourcegraph/server:3.29.0'
language='bash'
/>

This command is telling your computer to install and run Sourcegraph in port 7080 of your localhost (127.0.0.1) and is calling up the relevant files from the Docker image of Sourcegraph. It is also setting up a store for your Sourcegraph data.

Once you run the command, you’ll receive some output indicating that Sourcegraph is getting set up. Sourcegraph will be ready when you receive the output similar to the following:

<Highlighter
input='✱ Sourcegraph is ready at: http://127.0.0.1:7080'
/>

At this point, you’ll be able to move onto the next section to verify your installation.

### On an Apple M1 chip on macOS

On a macOS machine with an Apple M1 chip, you’ll need to add an extra argument to your Docker command so that the platform does not interfere with the installation and running of Sourcegraph. Run the following command with the `--platform linux/amd64` argument as demonstrated below.

<PrismSyntaxHighlighter
input='docker run \
--publish 7080:7080 \
--publish 127.0.0.1:3370:3370 \
--platform linux/amd64 \
--rm --volume ~/.sourcegraph/config:/etc/sourcegraph \
--volume ~/.sourcegraph/data:/var/opt/sourcegraph \
sourcegraph/server:3.30.4'
language='bash'
/>

This command is telling your computer to install and run Sourcegraph in port 7080 of your localhost (127.0.0.1) and is calling up the relevant files from the Docker image of Sourcegraph. It is also setting up a store for your Sourcegraph data.

Once you run the command, you’ll receive some output indicating that Sourcegraph is getting set up. Sourcegraph will be ready when you receive output similar to the following:

<Highlighter
input='✱ Sourcegraph is ready at: http://127.0.0.1:7080'
/>

At this point, you’ll be able to move onto the next section to verify your installation.

## Step 3 — Verify the installation

When Sourcegraph is fully installed and ready to be used, the Sourcegraph logo will appear and you should access the URL that is indicated in the Terminal output.

![Installation complete verification on command line](https://storage.googleapis.com/sourcegraph-assets/learn/tutorial-images/sourcegraph-logo-terminal.png)

Open a browser and go to the URL indicated in the output. Keep in mind that if you are using a local machine, you’ll be directed to the localhost, but on a server you should go to the IP address of that server.

The first time you open Sourcegraph, the page that will be displayed will be the page to setup your administrative account.

![Sourcegraph create account and login page](https://storage.googleapis.com/sourcegraph-assets/learn/tutorial-images/sourcegraph-login-page.png)

You can create the account now. This account will be tied to your own instance of Sourcegraph.

Once you set up your account, you’ll be able to add repositories and set up your preferences and configuration.

## Next steps

Congratulations! You have installed Sourcegraph with Docker and have created an account so that you can begin using Sourcegraph to search all of the code that is important to you.

Once you have Sourcegraph up and running, and your code repositories available to Sourcegraph, you can check our overview video on the [three ways to search with Sourcegraph](/three-ways-to-search-code-with-sourcegraph) so that you can more effectively search your code.


Installing Sourcegraph to search code on a local instance with macOS and Docker

Learn how to install Sourcegraph on your Apple Mac with Docker

How to install Sourcegraph on macOS with Docker


Sourcegraph is a tool that can allow you to search all the code that is important to you, from your own local repositories, to the software you build together with a team, to all the code that is available through open source projects. You can get started using Sourcegraph by using [Sourcegraph Cloud](https://sourcegraph.com/search) with your preferred web browser, or you may want to install Sourcegraph locally or on a cloud server or virtual machine.

By installing Sourcegraph on your own hardware, you’ll be able to manage your own instance of Sourcegraph, providing you with complete control over who has access to your code. Your own installation will also allow you to connect your local (or server-side) code as well as any relevant Git servers. Git servers that you can connect to include GitHub, GitHub Enterprise, GitLab, Bitbucket, AWS CodeCommit, Perforce, and more.

We’ll go through how to install Sourcegraph on your local Windows machine with Docker so that you can begin to use Sourcegraph on all of your code. 

---
**NOTE**:

Sourcegraph can only be tested on Windows 10 as data will not be retained after server restarts, due to a limitation of Docker on Windows.

---

This installation guide is appropriate for local testing and should be quick to set up. If you would like to use Sourcegraph in a production environment, you should follow our documentation on installing Sourcegraph with [Docker Compose](https://docs.sourcegraph.com/admin/install/docker-compose) on a single node, or on a [Kubernetes cluster](https://docs.sourcegraph.com/admin/install/kubernetes).

## Step 1 — Install Docker

_If you already have Docker installed, you can [skip to the next step](#step-2--install-sourcegraph)._

On a Windows machine, you can install Docker from the [Docker installation page for Windows](https://docs.docker.com/docker-for-windows/install/). Follow the guidance from the Docker installation.

With Docker fully installed, you’ll be ready to move onto the section below to install Sourcegraph. 

Please note that Sourcegraph can only be tested on Windows 10 as data will not be retained after server restarts, due to a limitation of Docker on Windows.

## Step 2 — Install Sourcegraph

Due to limitations with Docker for Windows, Sourcegraph can only be tested on Windows as data cannot persist on a Windows installation. Due to that, we won't be using the `--volume` argument in our command.

<PrismSyntaxHighlighter
input='docker run --publish 7080:7080 \
--publish 127.0.0.1:3370:3370 ` \
--rm sourcegraph/server:3.29.0'
language='bash'
/>

_The above command with backtick assumes use of PowerShell. If you're using the Windows Command Prompt, substitute `^` as below._

<PrismSyntaxHighlighter
input='docker run --publish 7080:7080 \
--publish 127.0.0.1:3370:3370 ^ \
--rm sourcegraph/server:3.29.0'
language='bash'
/>

This command is telling your computer to install and run Sourcegraph in port 7080 of your localhost (127.0.0.1) and is calling up the relevant files from the Docker image of Sourcegraph.

Once you run the command, you’ll receive some output indicating that Sourcegraph is getting set up. Sourcegraph will be ready when you receive output similar to the following:

<Highlighter
input='✱ Sourcegraph is ready at: http://127.0.0.1:7080'
/>

At this point, you’ll be able to move onto the next section to verify your installation.

## Step 3 — Verify the installation

When Sourcegraph is fully installed and ready to be used, the Sourcegraph logo will appear and you should access the URL that is indicated in the Terminal output.

![Installation complete verification on command line](https://storage.googleapis.com/sourcegraph-assets/learn/tutorial-images/sourcegraph-logo-terminal.png)

Open a browser and go to the URL indicated in the output. Keep in mind that if you are using a local machine, you’ll be directed to the localhost, but on a server you should go to the IP address of that server.

The first time you open Sourcegraph, the page that will be displayed will be the page to setup your administrative account.

![Sourcegraph create account and login page](https://storage.googleapis.com/sourcegraph-assets/learn/tutorial-images/sourcegraph-login-page.png)

As this is a test installation, you can choose whether this page satisfies your testing needs, or continue to create a test account and explore further.

## Next steps

Congratulations! You have installed a test environment of Sourcegraph with Docker on Windows and can begin using Sourcegraph to search all of the code that is important to you.

Once you have Sourcegraph up and running, and your code repositories available to Sourcegraph, you can check our overview video on [Three ways to search code with Sourcegraph](/three-ways-to-search-code-with-sourcegraph) so that you can more effectively search your code.


Installing Sourcegraph for code search testing on Windows with Docker

Learn how to install Sourcegraph on your Windows machine with Docker

How to install Sourcegraph on Windows with Docker


Sourcegraph is a universal code search tool, allowing you to search across your own code or public open source repositories that you add to your instance. You can begin experimenting with Sourcegraph through [Sourcegraph Cloud](https://sourcegraph.com/search), which is available in-browser and has millions of open source repositories indexed.

Once you know that you would like to self-host your own instance of Sourcegraph to search across your local or cloud repositories, and you want it to be suitable for a production environment, you can follow along with this tutorial that will set you up with a Sourcegraph instance on Docker Compose. This tutorial will assume *nix commands on the command line. 

If, instead, you would like to perform a quick install of Sourcegraph with Docker, which is suitable for testing environments, you can do so by following one of our tutorials for [Linux](https://learn.sourcegraph.com/how-to-install-sourcegraph-on-linux-with-docker), [cloud Linux](https://learn.sourcegraph.com/how-to-install-sourcegraph-with-docker-on-a-linux-cloud-server), [macOS](https://learn.sourcegraph.com/how-to-install-sourcegraph-on-mac-with-docker), or [Windows](https://learn.sourcegraph.com/how-to-install-sourcegraph-on-windows-with-docker).

Installing Sourcegraph into your production environment can allow you to use advanced features of Sourcegraph. You can also review our [installation documentation](https://docs.sourcegraph.com/admin/install).

## Prerequisites and estimating your setup needs

To install Sourcegraph with Docker Compose, your setup will need to meet certain requirements. We recommend following the official documentation to install [Docker](https://docs.docker.com/engine/install/) and [Docker Compose](https://docs.docker.com/compose/install/).

* You have [Docker](https://docs.docker.com/engine/install/) installed, and it’s v20.10.0 or above. 
* You have [Docker Compose](https://docs.docker.com/compose/install/) installed, and it’s v1.22.0 or above.
* Your machine or server has an estimated minimum number of 8 CPU cores.

Use the [resource estimator](https://docs.sourcegraph.com/admin/install/resource_estimator) to ensure that your machine meets the minimum requirements for your Sourcegraph instance needs based on the number of code repositories and number of users you are planning to set up on your instance. 

## Step 1 — Fork the reference repository

First, you will need to create a fork of the [sourcegraph/deploy-sourcegraph-docker reference repository](https://github.com/sourcegraph/deploy-sourcegraph-docker/).

You can fork the reference repository from GitHub’s user interface. Having a GitHub account is required when forking repositories that are hosted on GitHub.

To fork the repository using GitHub’s user interface, navigate to the [reference repository](https://github.com/sourcegraph/deploy-sourcegraph-docker/). On the right-hand side of the top navigation pane, you will find a **Fork** button.

![GitHub interface showing the Fork button on the Deploy Sourcegraph with Docker repo](https://storage.googleapis.com/sourcegraph-assets/learn/tutorial-images/fork-deploy-sourcegraph-docker-repo.png)

When you click on the **Fork** button, GitHub will create a fork of the repository for you.

With the forked repository, you can make customizations that are tailored to your organization’s needs. The original repository will remain as a source of truth when you need to make updates or upgrades to your Sourcegraph instance.


## Step 2 — Clone the forked repository

After forking the reference repository, you may want to create a directory or move to a directory on your machine or host where the fork will live. Clone the forked repository into this directory, which is called the configuration directory.

For our example, we’ll move into a temporary directory, `~/tmp`.

<PrismSyntaxHighlighter
input='cd ~/tmp'
language='bash'
/>

Enter the following command on your terminal to clone your forked repository. Be sure to substitute _your username_ where we have `your-username` written out in the URL.

<PrismSyntaxHighlighter
input='git clone https://github.com/your_username/deploy-sourcegraph-docker/'
language='bash'
/>

You should receive output similar to the following:

<Highlighter
input={`Cloning into 'deploy-sourcegraph-docker'...
...
Resolving deltas: 100% (4418/4418), done.`}
/>

Once you clone the Git repository, all the relevant code lives locally on your machine or server. You now have a copy of the reference repository that you can configure to suit your needs.


## Step 3 — Add the reference repository as upstream remote

A connection to the upstream repository you forked in [Step 1](#step-1--fork-the-reference-repository) gives you the necessary connection to pull from the reference as needed. Remote repositories are versions of your project that are hosted online, in this case it is the main reference project maintained by Sourcegraph.

To set up your reference to the remote upstream repository, you’ll first need to move into the directory of your cloned repo. For our example, the path is the following, but be sure to use the path relevant to your machine and file structure. 

<PrismSyntaxHighlighter
input='cd ~/tmp/deploy-sourcegraph-docker/'
language='bash'
/>

From within the `/deploy-sourcegraph-docker` directory, use the following command that passes in the URL of the `sourcegraph/deploy-sourcegraph-docker` project to set up the remote upstream. 

<PrismSyntaxHighlighter
input='git remote add upstream https://github.com/sourcegraph/deploy-sourcegraph-docker'
language='bash'
/>


If everything was successful, you will be at a new line of your terminal, with no other output.

Because you have pull access, you can keep up with changes on the reference repository by pulling the main branch whenever there is an update.

## Step 4 — Install Sourcegraph on your host

Move to the configuration directory (the file path on your machine that contains the clone to the fork you created), and navigate to the Docker Compose folder.

<PrismSyntaxHighlighter
input='cd ~/tmp/deploy-sourcegraph-docker/docker-compose'
language='bash'
/>

Within this directory, you can spin up the Sourcegraph instance on your host with Docker Compose. Here, `up -d` refers to starting the containers in the background and leaving them running; the `-d` flag refers to running the containers in a **d**etached mode.

<PrismSyntaxHighlighter
input='sudo docker-compose up -d'
language='bash'
/>

Once you run this, you will know that your installation was successful when you receive output that generates `done` messaging, and output that notifies you that Sourcegraph is ready. This will display with your server or localhost IP address and the relevant port.


<Highlighter
input='Sourcegraph is ready at: [an-address-and-port-created-by-your-server]'
matcher='an-address-and-port-created-by-your-server'
/>

You can access Sourcegraph using the relevant IP address and port number. 

## Step 5 — Check that the service is healthy

After receiving the message that Sourcegraph is ready, you will need to check that the service is healthy by running the Docker process command or `docker ps` for short.

Sometimes, a service may be running but cannot respond to requests because a required step is not complete. Running a health check lets you know the actual state of the service.

<PrismSyntaxHighlighter
input='docker ps'
language='bash'
/>

The instance is healthy when the `sourcegraph-frontend-0` image is running and is marked as “healthy” on your host’s terminal.

<Highlighter
input='[your-container-id]  sourcegraph-frontend-0  "/sbin/tini -- /usr/…"  Up 20 minutes(healthy)'
matcher='your-container-id'
/>

A service will be marked as healthy if it has fulfilled all the checks that it needs to run.

## Step 6 — Access Sourcegraph with a browser

Copy the IP address created by your server and access it with a web browser of your choice. The link leads to a page that lets you create an account to start using Sourcegraph.

![Sourcegraph signup landing page](https://storage.googleapis.com/sourcegraph-assets/learn/tutorial-images/sourcegraph-docker-compose-signup.png)

After successfully installing Sourcegraph with Docker Compose, you can [create a Sourcegraph Account](https://learn.sourcegraph.com/how-to-create-a-self-hosted-sourcegraph-account).

## Next steps

Now that you have Sourcegraph installed and you also have a Sourcegraph account, you can check out our [Sourcegraph resources](https://learn.sourcegraph.com/tags/sourcegraph) to find helpful guides on how to use Sourcegraph effectively. 

You can also learn more about Sourcegraph by reviewing our product [docs](https://docs.sourcegraph.com/).


Install self-hosted Sourcegraph for a production environment

Install a self-hosted Sourcegraph instance for a production environment to search all of your code

How to install Sourcegraph with Docker Compose


If you are working in Python, and receive the following output, your code is attempting to divide a given number by zero.

<PrismSyntaxHighlighter
input='ZeroDivisionError: division by zero'
language='python'
/>

In mathematics, division by 0 is undefined. Because of this, Python will issue the above error when your code tries to accomplish this undefined expression. 

In this tutorial, we'll reproduce the issue and then go over some solutions.

## Reproducing the error

Let's write the following program, `divide.py`. 

<PrismSyntaxHighlighter
input={`def divide_two_numbers():
    a = input("Enter an integer: ")
    b = input("Enter another integer: ")
 
    c = int(a)/int(b)
    print(c)
  
divide_two_numbers()`}
language='python'
/>

This small program creates a function that divides `a` by `b` to return `c`. The integers `a` and `b` are input by the user of the program, so a user can unknowingly enter `0` as the second integer.

If the user enters `9` and then `3`, there will be no errors returned, as indicated in the output below.

<PrismSyntaxHighlighter
input='Enter an integer: 9
Enter another integer: 3
3.0'
language='python'
/>

If, however, the user enters `9` and then `0`, we will be able to reproduce the `ZeroDivisionError`.

<PrismSyntaxHighlighter
input={`Traceback (most recent call last):
  File "divide.py", line 8, in <module>
    divide_two_numbers()
  File "divide.py", line 5, in divide_two_numbers
    c = int(a)/int(b)
ZeroDivisionError: division by zero`}
language='python'
/>

Now that we have been able to reproduce the error, let's go over possible solutions.

## Return 0

You can use flow control in the form of an `if` / `else` statement to reach an alternate outcome. 

<PrismSyntaxHighlighter
input={`def divide_two_numbers():
    a = input("Enter an integer: ")
    b = input("Enter another integer: ")
 
    c = (int(a)/int(b)) if int(b) != 0 else 0
    print(c)
  
divide_two_numbers()`}
language='python'
/>

In this example, we have the program check to ensure that `b` is not equal to `0`, and if it is to instead print `0`. In this case, our output with a `0` denominator would be a `0`.

<PrismSyntaxHighlighter
input='Enter an integer: 9
Enter another integer: 0
0'
language='python'
/>

While this solution prevents an error, it does not give the feedback that our expression is undefined, and may not be the best solution for you, depending on the requirements of your program.

## Return a string with guidance 

Flow control and an `if` / `else` statement can also be used to print output to give guidance, or give the user direction.

<PrismSyntaxHighlighter
input={`def divide_two_numbers():
    a = input("Enter an integer: ")
    b = input("Enter another integer: ")
 
    if int(b) == 0:
        c = "This expression is undefined."
 
    else:
        c = int(a)/int(b)
 
    print(c)
  
divide_two_numbers()`}
language='python'
/>

Here, we first check whether `b` is equivalent to `0`, and if so, we initialize `c` as a string that states that `This expression is undefined.`

<PrismSyntaxHighlighter
input='Enter an integer: 9
Enter another integer: 0
This expression is undefined.'
language='python'
/>

You may want to provide even more guidance to the user, to let them know that they can't divide by `0`, or to put this workflow in a loop so that the user can try again.

## Exception handling

A third approach is to handle the exception with a `try` / `except` clause that calls the `ZeroDivisionError`.

<PrismSyntaxHighlighter
input={`def divide_two_numbers():
 
    try:
        a = input("Enter an integer: ")
        b = input("Enter another integer: ")
 
        c = int(a)/int(b)
 
    except ZeroDivisionError:
        c = "You cannot divide by 0."
 
    print(c)
 
divide_two_numbers()`}
language='python'
/>

Here, we first have the program attempt our original workflow, but use the `except` clause to handle the `ZeroDivisionError` that we have anticipated. 

<PrismSyntaxHighlighter
input='Enter an integer: 9
Enter another integer: 0
You cannot divide by 0.'
language='python'
/>

In this example, we have told the user that they cannot divide by 0 if they attempt to do so.

## Learn more

Search across open source Python repositories that have the `ZeroDivisionError` to understand the message more.

<SourcegraphSearch query="ZeroDivisionError: division by zero lang:python" patternType="literal"/>

Read the official Python docs on [Errors and Exceptions](https://docs.python.org/3/tutorial/errors.html).

Check out more Sourcegraph Learn tutorials on [Python](https://learn.sourcegraph.com/tags/python).

ZeroDivisionError division by zero in Python error handling

Learn how to error handle the Python ZeroDivisionError, division by zero

How to troubleshoot Python ZeroDivisionError


<EmbeddedYoutubeVideo id="_dGkagmwZqU" />

## Transcript

Reading and searching open source code really helps me understand my project dependencies, it helps me optimize my code, and it helps me figure out how to best implement a new feature. I also find that real-life examples in open source code help new developers learn effectively, and can encourage them to become contributors to open source, too!

I’m Lisa, Director of Developer Education at Sourcegraph, and the team here is working on indexing every open source repository on GitHub and GitLab with at least one star. You, too, can add open source repositories to Sourcegraph Cloud to help others be able to search across many repos. I’ll walk you through the process.

### Manage repositories from your Sourcegraph Cloud account

First, you’ll need to have an account on Sourcegraph Cloud. Once you sign up or login, you’ll click on your user icon on the top right corner of the page. From the drop-down menu, click on **Repositories**. If you have repositories on your account already, click through to **Manage Repositories**.

From here you will be able to connect your own repositories to Sourcegraph, but for now, we’re going to scroll down to **Other public repositories**. We’ll click on the checkbox **Sync specific public repositories by URL**. 

### Add links to public repositories

In the box, you can add links to these public repos, whether you contribute to the project or not. These are probably open source projects that you care about. Add one URL per line with no separating characters other than the `ENTER` key.

I have identified two projects that I would like to have Sourcegraph index. One of them is this [Cloud Haiku repository](https://github.com/do-community/cloud_haiku), I’ll go through, copy, and paste. Then I’ll hit `ENTER` to start a new line — don’t put any characters in between. Then I’ll go through and copy paste for the second repository, which is an [archive of computational history](https://github.com/dhmit/computation_hist). When you are satisfied with the repositories that you have added, you can click the **Save** button below. You can always add more repos later!

### Verify that repositories have been added

Once I've clicked on **Save** I should see that these repositories are loaded in, preloaded to my account. And now I can actually check to make sure that Sourcegraph has in fact indexed these repositories by looking for a specific string that I know exists in one of them. So, first I’ll identify that string and share that with you really quickly.

In this Cloud Haiku repository, there is this line, “Like the octopuses’ minds” and a break. I suspect this is not a common line in open source repositories. So what I’m going to do next is open a private or incognito window and then I’m going to search Sourcegraph for this specific line to make sure that it is globally available. 

Now I have my private window, I’m going to go to sourcegraph.com and I’m going to search that line that I mentioned before. So this is “Like the octopuses’ minds” with a break. I am in the context:global search, I am not logged in, and I am going to hit the **Search**. So here we see that there are actually a few instances of this line, but it is limited to this repo. This repo is the one that I just added, so we know that that repository has been indexed by Sourcegraph. Now, even an anonymous user, not logged in, will be able to access the open source repos that I just added. 

Looking forward to seeing the open source repositories that you’ll add to Sourcegraph. Happy coding and happy searching through open source!

## Related links

To learn more about Sourcegraph Cloud, check out our full written tutorial on [How to add open source software projects to Sourcegraph Cloud](https://learn.sourcegraph.com/how-to-add-open-source-software-projects-to-sourcegraph-cloud) and our tutorial on [How to add private code repositories to Sourcegraph Cloud](https://learn.sourcegraph.com/how-to-add-private-code-repositories-to-sourcegraph).


Sourcegraph is indexing open source

Find out how to add open source repos to Sourcegraph Cloud so you can search across all the code you care about.

How to add open source software to Sourcegraph Cloud (video)


<EmbeddedYoutubeVideo id="u_SmtOejFkg" />

## Transcript

Hi, I’m Lisa, Director of Developer Education at Sourcegraph, and I’m going to walk you through installing an instance of Sourcegraph on a Linux Ubuntu 20.04 cloud server. We’ll be using a [DigitalOcean Droplet](https://www.digitalocean.com/) with the recommended 4GB of RAM and 2 CPUs for this demo.

Sourcegraph is a tool that can allow you to search the code that is important to you. You can try out [Sourcegraph Cloud](https://sourcegraph.com) on the web to search through open source repositories right now. In this video, we’ll discuss an installation instead. If you would like to use Sourcegraph to access local code, server-side code, or code from several different code hosts, an instance like this may be the right fit for you. 

Installing Sourcegraph with Docker is appropriate for testing and fairly quick to set up. If you would like to use Sourcegraph in a production environment, you should follow our documentation on installing [Sourcegraph with Docker Compose](https://docs.sourcegraph.com/admin/install/docker-compose) on a single node, or on a [Kubernetes cluster](https://docs.sourcegraph.com/admin/install/kubernetes). Let’s get started.

### Server setup

I set up this DigitalOcean Droplet with a [non-root sudo user](https://www.digitalocean.com/community/tutorials/initial-server-setup-with-ubuntu-20-04), Sammy. First, I want to make sure that everything is up to date by running the following command. 

<PrismSyntaxHighlighter
input='sudo apt update'
language='bash'
/>

I’ll enter the password when prompted to use my sudo user. 

Now we know everything is up to date, and I can move ahead to installing Docker. I am going to use the snap package manager, so let’s make sure that’s installed. 

<PrismSyntaxHighlighter
input='sudo apt install snapd'
language='bash'
/>

With that installed and set up, I want to make sure I have the core libraries I need, so I’ll run sudo snap install core.

<PrismSyntaxHighlighter
input='sudo snap install core'
language='bash'
/>

Now that snap is installed, we’ll install Docker using snap.

<PrismSyntaxHighlighter
input='sudo snap install docker'
language='bash'
/>

Now that we have Docker installed, we can move on to installing Sourcegraph with Docker.

### Installing Sourcegraph

We have a multi-line Docker command that we need to run, and we’ll demonstrate how to do that here. We’ll be using the sudo command and it’s going to take a little bit. 

We’ll run the following Docker run command:

<PrismSyntaxHighlighter
input='sudo docker run -d --publish 80:7080 \
--publish 443:7443 \
--restart unless-stopped \
--volume /root/.sourcegraph/config:/etc/sourcegraph \
--volume /root/.sourcegraph/data:/var/opt/sourcegraph \
sourcegraph/server:3.30.4'
language='bash'
/>

This command is telling your server to install and run Sourcegraph, binding port 7080 to TCP port 80 of your server; it’s calling up the relevant files from the Docker image of Sourcegraph. Since this is a cloud server, we can keep our instance of Sourcegraph up and running even after closing our Terminal connection to the server, and that was one of the details we pass to this command. It is also setting up a store for your Sourcegraph data.

### Verify installation

With our installation complete, we can navigate to our web browser of choice and enter the IP address of the server with port 80. We’ll press enter and get the feedback that the installation is complete. We have validated that we have installed Sourcegraph with Docker on this Ubuntu server. At this point, you can create your account. 

Now we have verified that everything is working. For next steps, head on over to [Sourcegraph Learn](https://learn.sourcegraph.com). Or go ahead to read through our [documentation](https://docs.sourcegraph.com) to read more about Sourcegraph, the different installation methods, and how you can effectively search all of your code. Happy coding and happy searching!

_For a longer-form written tutorial of this guide, read “[How to install Sourcegraph on Linux with Docker](https://learn.sourcegraph.com/how-to-install-sourcegraph-on-linux-with-docker).”_


Test a Sourcegraph installation with Docker on DigitalOcean to search your code

Install Sourcegraph onto a DigitalOcean Ubuntu cloud server with Docker.

Lisa Tagliaferri