
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 a universal code search tool, enabling you to search across both open source and your own private code repositories. Code search can help you onboard onto new codebases, contribute to open source, find bugs and error messages, understand dependency libraries, and more.

This cheat sheet style guide can help you get up to speed with Sourcegraph commands quickly. For more thorough tutorials on using Sourcegraph, refer to our [tutorials](https://learn.sourcegraph.com/tags/sourcegraph) and our [documentation](https://docs.sourcegraph.com/). 

You can use these commands on either [Sourcegraph Cloud](https://sourcegraph.com/search) or your own [Sourcegraph instance](https://docs.sourcegraph.com/admin/install).

## Searching an organization’s repository

By default, Sourcegraph lets you search globally, providing you with results from all the repositories you have access to. On Sourcegraph Cloud, this includes all currently indexed open source repositories. The `repo` command lets you dial down to the single repository level.

### Searching for or within a repository

The `repo` keyword lets you search a specific repository in your organization or on the web.

<Highlighter
input='repo:repository-path'
matcher='repository-path'
/>

<Highlighter
input='repo:regular-pattern'
matcher='regular-pattern'
/> 

Searching with `repo:^github\.com/ORGANIZATION` will return all repositories in a given organization, where `ORGANIZATION` can be `sourcegraph`, for example.

<SourcegraphSearch query="repo:^github\.com/sourcegraph/.*" />


The `repo` keyword contextualizes the searches you perform on Sourcegraph. 

### Repository search: command chaining

When searching a repository, command chaining can be used to return more specific results depending on the expected results.

**Search for a repository that contains a file**

If you are searching for a file in a repository, use `repo:contains.file`.

<Highlighter
input='repo:repository-path repo:contains.file(file-path)'
matcher='file-path'
/> 

For example, when searching for the `package.json` file in a project, this search query will return the file.

<SourcegraphSearch query="repo:^github\.com/sourcegraph/.* repo:contains.file(package.json)" />

A similar example that uses the content query to search for files is shown below.

<SourcegraphSearch query="repo:contains(file:package\.json$ content:ts)" />

This query returns repositories that contain a `package.json` file and has content written in TypeScript.

**Search for a repository that contains some content**

Suppose you are searching for some content in a repository, such as a library. Use `repo:contains.content`.

<Highlighter
input='repo:repo-path repo:contains.content(your-content)'
matcher='your-content'
/> 

<Highlighter
input='repo:repo-path repo:contains.content(regular-pattern)'
matcher='regular-pattern'
/> 

We can search for the `mdi-react` library in Sourcegraph, for example:

<SourcegraphSearch query="repo:^github\.com/sourcegraph/.* repo:contains.content(mdi-react)" />


The above query returns repos that have `mdi-react` among its contents.

## Language-specific search

Use `lang` when searching code to narrow the scope of your search to one programming language. 

<Highlighter
input='lang:programming-language'
matcher='programming-language'
/> 

We can search for results within the C++ or Python programming languages.


<SourcegraphSearch query="lang:c++" />

<SourcegraphSearch query="lang:python" />


By default, searches are case insensitive.

Prepending a hyphen can exclude results from a particular programming language.

<Highlighter
input='-lang:programming-language'
matcher='programming-language'
/> 

To exclude Java, you can perform the following search.

<SourcegraphSearch query="​​-lang:java" />

Narrowing your search scope down to specific languages can ensure that you find the code that is most relevant to your needs.

## Searching based on time periods

If you are searching for code committed before or after a time period, you will use `before` and `after`

<Highlighter
input='before:time-period
after:time-period'
matcher='time-period'
/> 

Sometimes the time period can be relative, like `last week`, `last year`, `3 months ago` or absolute, in several formats including `{month} {day} {year}` (example: `february 10 2021`), `dd/mm/yyyy`, and ISO format `yyyy-mm-dd`.

<Highlighter
input='before:last week'
matcher='last week'
/> 

<Highlighter
input='after:february 10 2021'
matcher='february 10 2021'
/> 

<Highlighter
input='before:02/01/2019'
matcher='02/01/2019'
/> 

To search between dates, keywords like `and` can be combined with `before` or `after` to return dates within a given period.

<SourcegraphSearch query='repo:sourcegraph type:commit after:"july 9 2021" and before:"july 10 2021"' />

Time-based search is usually used along with other search commands to further narrow down search results.

Note that `before` and `after` only work in conjunction when combined with `type:diff` or `type:commit` commands.

## Search in archived repositories

The `archived` keyword will bring up those results from repositories that have been archived.

<Highlighter
input='archived:yes'
matcher='yes'
/> 

<Highlighter
input='archived:no'
matcher='no'
/> 

<Highlighter
input='archived:only'
matcher='only'
/> 

We can surface only archived repositories within the Sourcegraph organization with the following query.

<SourcegraphSearch query="repo:sourcegraph archived:only" />

This can help us understand past decisions made within a given codebase. 

## Case sensitive search

Use `yes` or `no` with the `case` search query to specify if the search should be case sensitive or not. By default, searches are case insensitive.

<Highlighter
input='case:yes'
matcher='yes'
/> 

<Highlighter
input='case:no'
matcher='no'
/> 

Suppose you would like to check to align the style of a given codebase to help you bring all function calls in Python to be consistent with the [PEP 8](https://www.python.org/dev/peps/pep-0008/) guidance. You can use Sourcegraph to understand which functions are using camelCase rather than lowercase names with underscores between words (also called snake_case).

<SourcegraphSearch query="case:yes lang:python myFunction" />


If you would like to find all declared functions that use camelCase, you can try combining this query with regular expressions.

## Searching by types

Types define the scope of code search. A search scope consists of commits, diffs, symbols, repos, paths and files. It is typically used alongside other search commands to further narrow search results.

<Highlighter
input='type:commit|path|diff|symbol|repo|file'
matcher='commit|path|diff|symbol|repo|file'
/> 

Here is an example to show us time-based commits on the Sourcegraph repo.

<SourcegraphSearch query="repo:sourcegraph after:yesterday type:commit" />

A `type` scope can use the following commands, which will restrict search to the following:
* `commit` — commits to a repository.
* `path` — restricts terms to matching filenames only (not file contents).
* `diff` — show [diffs](https://git-scm.com/docs/git-diff), or changes, within a repository.
* `repo` — repositories available to you.
* `file` — restricts terms to matching file contents only (not filenames).
* `symbol` — returns files that contain names or keywords in a library.

Searching by type can help you find exactly what you need in a codebase by narrowing down the scope of your search. 

## Searching commit messages matching a string

If a commit message is known, it can be helpful to use the `message` keyword to bring up relevant commits.

<Highlighter
input='message:commit-message'
matcher='commit-message'
/> 

<Highlighter
input='message:string-regex-pattern'
matcher='string-regex-pattern'
/> 

We can find all commit messages with “fix” in the `sourcegraph/sourcegraph` repository by searching the following.

<SourcegraphSearch query="repo:^github\.com/sourcegraph/sourcegraph$ type:commit message:fix" />

Note that the message keyword only works for `type:diff` or `type:commit` queries.

## Searching code by commits and diffs 

The `author` keyword returns code search results that were created by a user. This keyword only works for `type:diff` or `type:commit` queries.

<Highlighter
input='author:author-name'
matcher='author-name'
/> 

Adding a hyphen in front of the `author` keyword omits code content created by a given author.

<Highlighter
input='-author:author-name'
matcher='author-name'
/> 

Search for all code diffs by the Renovate app within our Sourcegraph repository.

<SourcegraphSearch query="repo:^github\.com/sourcegraph/sourcegraph$ author:renovate type:diff" />

You can also search by `committer:git-email` with the same `type` constraints.

## Return a certain number of results

Sourcegraph returns pages filled with search results. To stop searching after a given number of results are returned, use the `count` command.

<Highlighter
input='count:number|all'
matcher='number|all'
/> 

For example, `count:5` would return the first 5 results of a given query.

<SourcegraphSearch query="repo:sourcegraph/learn type:commit count:5" />

The `all` option returns all results from a search.

The `count` keyword may also be used to return _more_ results, not just  _fewer_ results. This can enable you to display more than the default 500 results that are returned.

## Searching for or within forks

The `fork` keyword restricts the scope of search results to either include, exclude, or return only  forks of a given repository.

<Highlighter
input='fork:yes|no|only'
matcher='yes|no|only'
/> 

The `yes` option includes forked repositories, the `no` option omits the results from forks, and the `only` option searches only forked repositories.

One use case for searching forked repositories is looking for how users personalize open source libraries.

## Timing out searches

To set the duration before a search times out, you’ll use the `timeout` keyword. Time units that can be used include nanoseconds (`ns`), microseconds (`us` or `µs`) , milliseconds (`ms`), seconds (`s`) or minutes (`m`).

<Highlighter
input='timeout:time-duration-with-unit'
matcher='time-duration-with-unit'
/> 

This is useful when searching many repositories at the same time to give search more time to return useful results. By default, timeout is 10 seconds, however, when using the `timeout` command, timeouts can be set to over a minute. When this scope is provided, search is given more time to complete.

<SourcegraphSearch query="timeout:40s" />

Alternatively, if you are receiving too many results, you can decrease the time of search.

## Search by repository visibility

Restricting search by codebase visibility is done with the `visibility` command. You can restrict search to public or private repositories.

This is useful if you want the results of a search to be explicitly narrowed down to repositories that are private and accessible to you or repositories that are public. 

Except when explicitly set, all searches return results from both public and private repositories accessible to you.

<Highlighter
input='visibility:any|private|public'
matcher='any|private|public'
/> 

When logged into Sourcegraph, you can change your context to your username and then run the following command to show all of your available private repositories.

<SourcegraphSearch query="visibility:private" />

This can allow you to search across the code that is private to only you. _Please note that searching private code on Sourcegraph Cloud is currently in Public Beta._

## Further resources

To learn more about how to search effectively with Sourcegraph, you can read through our Sourcegraph search series:
* [How To Search with Sourcegraph using Literal Patterns](/how-to-search-code-with-sourcegraph-using-literal-patterns)
* [How To Search with Sourcegraph using Regular Expression Patterns](/how-to-search-with-sourcegraph-using-regular-expression-patterns)
* [How To Search with Sourcegraph using Structural Patterns](/how-to-search-with-sourcegraph-using-structural-patterns)

You can also check out [Sourcegraph product documentation](https://docs.sourcegraph.com/) and [Sourcegraph tutorials](https://learn.sourcegraph.com/tags/sourcegraph).


Getting started with Sourcegraph universal code search

A guide to help you get up to speed with Sourcegraph's commands quickly

How to search code with Sourcegraph — a cheat sheet


Sourcegraph code search is a search engine that allows you to search code in your own repositories as well as across public open source code. It supports three kinds of search patterns: literal patterns, regular expression patterns, and structural patterns. In this article, we’ll explore literal search patterns and how to use them.

Performing a literal search is useful when you know the exact string that you’re looking for in a code base, like a particular function or variable name. You can find all occurrences of the name across multiple repositories by using your query as a literal pattern. It’s also useful for finding textual content — like error messages or comments — in the code.

By default, all search queries on Sourcegraph are treated as literal patterns. We’ll discuss a few use cases to find useful results with Sourcegraph.

## Finding function calls and definitions

As a developer, there are many times you may need to learn a new codebase: you may need to understand how best to use a new package, may need to be onboarded into an existing project, or may want to learn best practices from tried and tested software. A productive way to become familiar with a codebase is through selecting a function and understanding how it’s used throughout the code and in what contexts.

For example, if you’re learning how the Linux kernel works, one of the topics that you may want to understand is how Linux uses linked lists. Because linked lists are used throughout the Linux kernel and in driver code, they are a foundational starting point to familiarize yourself with the codebase.

The linked list data structure in Linux is called `list_head`. We can find all instances of the `list_head` structure by searching for it directly:

<SourcegraphSearch query="list_head"/>

As you review the results, you may notice that there are some common functions that are frequently used together with linked lists. One of these functions is `list_add_tail`. To explore further and find all instances of `list_add_tail`, we can start a new search for that specific function:

<SourcegraphSearch query="list_add_tail"/>

Literal search patterns can be used to find more than just functions or variables. They can also be used to find longer pieces of text, like error messages, as we’ll explore in the next section.

## Finding error messages

Literal search can help you find where a particular piece of text occurs within code. For example, if you’re seeing an error message while debugging, it can be helpful to find where that message is defined in the code to get a better idea of what is causing it. You can search for an exact match by copying the error into your search.

Let’s try an example. React is a framework used by many web apps, and its error messages are sometimes hard to debug. When a React component throws an error, it produces an error message like, `React caught an error thrown by Component`. When you get an error message like that, it isn’t always clear what is going on. To learn more about the source of the error, you can search for the error message itself:

<SourcegraphSearch query="React caught an error thrown"/>

By finding where an error message is defined, you can start to understand what conditions will cause this error. In this case, it happens when React catches an error that happened during the rendering phase in one of your components.

This kind of search also gives you an understanding of the inner workings of the codebase, and that can be really helpful to get a better mental model of how it works.

## Finding sequences of words

By default, when searching for literal patterns in Sourcegraph, the entire query will be searched, even if the pattern consists of multiple worlds. You should not put your query in quotes: we’ll go into more detail about this now.

Unlike a web search engine, if you search for two or more words on Sourcegraph, like `const counter`, then you’ll only get results for `const` immediately followed by `counter`, as in the example below.

<SourcegraphSearch query="const counter"/>

Returning to our example in the Linux kernel, we can narrow down our search for `list_head` to only the cases where it’s used as a simple structure ([`struct`][struct]), by searching specifically for the `struct list_head` pattern:

<SourcegraphSearch query="struct list_head"/>

If you want to find all instances of those two words appearing in the same file but not necessarily in sequence, then you can use the `and` operator, or you can switch to regular expression mode.

To use the `and` operator, add it to your search. The following query will find occurrences of `list_head` and `list_add_tail` when they are present anywhere in the same file.

<SourcegraphSearch query="list_head and list_add_tail"/>

If you try one of these examples with quotes around the search query, like `"const counter"`, you’ll notice that you get no results. This is because the quote characters are interpreted literally, so Sourcegraph will search for textual data that includes those quote characters.

There are cases where searching for quote characters is useful. We’ll explore that in the next section.

## Finding quoted string constants

Because quote characters are treated like any other character when you’re in literal pattern mode, you can search for quoted strings by including the quotes in your search.

For example, the quoted string `"ENOENT"` represents the error when a file is not found in Linux, and it’s found in many codebases:

<SourcegraphSearch query='"ENOENT"'/>

By including the quotes in the search query, you can compare this search with the same string, but without quotes. You’ll receive other results, where the string isn’t necessarily in quotes.

<SourcegraphSearch query='ENOENT'/>

## Learn more

We’ve explored how to use Sourcegraph to search for literal patterns like function names, variables names, error messages, and strings. You can learn more about Sourcegraph search syntax in the [documentation].

Literal search patterns are a useful starting point, but often you need to search for patterns in your code that require more flexibility. Sourcegraph offers two other types of patterns: [regular expressions] and [structural search].

To go beyond literal patterns, you can use regular expressions or structural search patterns.

**Related links:**

- [Sourcegraph search query documentation][documentation]
- [Sourcegraph regular expression search][documentation]
- [Sourcegraph structural search][structural search]

[struct]: https://en.wikipedia.org/wiki/Struct_(C_programming_language)
[documentation]: https://docs.sourcegraph.com/code_search/reference/queries
[regular expressions]: https://docs.sourcegraph.com/code_search/reference/queries#regular-expression-search
[structural search]: /how-to-search-with-sourcegraph-using-structural-patterns


Searching code with Sourcegraph using literal search

Learn how to use literal search patterns to search code on Sourcegraph.

How to search code with Sourcegraph using literal patterns


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

Code search

A short history of code search

How to search code with Sourcegraph — a cheat sheet

How to search code with Sourcegraph using literal patterns

Sourcegraph

How to add open source software projects to Sourcegraph Cloud

How to add private code repositories to Sourcegraph Cloud

How to create a self-hosted Sourcegraph account