# Repo Structure

In this section, we will explore the current Deno repository structure, such that you won't feel lost.

Here is the link to the repo: <https://github.com/denoland/deno>

We will list some of the important directories/files you might need to interact with, and briefly introduce each of them:

```
# DIRECTORIES
build_extra/: Some customized rules of building Deno
js/: TypeScript Frontend
libdeno/: C/C++ Middle-end
src/: Rust Backend
tests/: Integration Tests
third_party/: Third party code
tools/: Deno tools for testing and building

# FILES
BUILD.gn: Main Deno build rules
Cargo.toml: Dependency info for Rust end
package.json: Node dependencies (mostly for TypeScript compiler and Rollup)
build.rs: Cargo build rules
```

## build\_extra/

Some customized rules for building Deno, consisting of rules for FlatBuffers and Rust crates at the moment.

One important file you might want to pay attention to is `build_extra/rust/BUILD.gn`. When adding a new Rust crate in `third_party/`, we need to add an entry into this file. For example, this is the rule for building a crate called `time`:

{% code title="build\_extra/rust/BUILD.gn" %}

```
rust_crate("time") {
  # Where is this crate?
  source_root = "$registry_github/time-0.1.40/src/lib.rs"
  # What are its dependencies?
  extern = [
    ":libc",
    ":winapi",
  ]
}
```

{% endcode %}

(`rust_crate` GN template is defined in `build_extra/rust/rust.gni`)

## js/

This is where code for TypeScript frontend is located. Most APIs are defined in its own file, accompanied with a test file. For example, `readFile` is defined in `read_file.ts`, while its unit tests are in `read_file_test.ts`.

Besides files for API, here are some other special files:

1. `main.ts`: `denoMain` is defined in this file, which is invoked by Rust backend as the entry for bootstrapping TypeScript code.
2. `globals.ts`: All globals that do not need imports are attached here.
3. `deno.ts`: All `deno` namespace APIs are exported here.
4. `libdeno.ts`: Type definition for customized V8 API exposed to TypeScript.
5. `unit_tests.ts`: All unit tests are imported here and executed.
6. `compiler.ts`: Customized TypeScript compilation logic for Deno.

## libdeno/

The C/C++ libdeno middle-end lives here.

1. `api.cc`: libdeno APIs that are exposed and callable from the Rust side
2. `binding.cc`: code that handles interaction with V8 and where V8 C++ bindings are added. These APIs are exposed Rust and TypeScript side both.
3. `snapshot_creator.cc`: logic for creating V8 snapshot during build.

## src/

The Rust backend lives here.

1. `libdeno.rs`: exposes libdeno APIs from `libdeno/api.cc` to Rust
2. `isolate.rs`: extracts V8 isolate (an isolated instance of V8 engine) and event loop creation logic using libdeno APIs
3. `deno_dir.rs`: contains logic for Deno module file resolution and caching
4. `ops.rs`: where each Deno Op (operation) is handled. This is where the actual file system and network accesses are done.
5. `main.rs`: contains main function for Rust. This is the **ACTUAL** entry point when you run the Deno binary.
6. `msg.fbs`: FlatBuffers definition file for message structure, used for message passing. Modify this file when you want to add or modify a message structure.

## tests/

Integration tests for Deno.

`*.js`or `*.ts` files define the code to run for each test. `*.test` defined how should this test be executed. Usually, `*.out` defines the expected output of a test (the actual name is specified in `*.test` files)&#x20;

See [tests/README.md](https://github.com/denoland/deno/blob/master/tests/README.md) for more details.

## third\_party/

Third party code for Deno. Contains actual node modules, v8, Rust crate code and so on. It is placed in <https://github.com/denoland/deno_third_party>.

## tools/

Mostly Python scripts for a range of purposes.

1. `build.py`: Builds Deno
2. `setup.py`: Setup and necessary code fetching
3. `format.py`: Code formatting
4. `lint.py`: Code linting
5. `sync_third_party.py`: Sync third\_party code after user modifies `package.json`, `Cargo.toml` , etc.

## BUILD.gn

Contains the most important Deno build logic. We will visit this file later in the example of adding a new Deno call.

## build.rs

Defines `cargo build` logic. Internally invokes `BUILD.gn`.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://denolib.gitbook.io/guide/codebase-basics/repo-structure.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.