NESsie-set - Next Edit Suggestion Dataset

NESsie-set, the dataset of the Next Edit Suggestion model NESsie, is mined from real edits in open-source GitHub commits. Each row is a single example: given a snapshot of a coding trajectory (the current state of the file being edited plus the recent edit history), the task is to predict the developer's next edit. Code completion predicts what is typed at the caret; next edit suggestion also covers deletions and modifications anywhere in the file.

Dataset summary

• Source: edits mined from public GitHub commits of repositories with permissive licenses.
• Size: 147,885 examples from 9,146 repositories.
• Splits: train 83,293, validation 32,513, test 32,079.
• Languages: 17 (see Statistics).
• Format: one self-contained example per row; columns are nested structs (see Item format). Retrieved context is a separate configuration.

How the data is collected

• Repositories. A crawler discovers repositories per language and pins each to a commit. Only repositories whose license GitHub classifies as one of Apache-2.0, BSD-2-Clause, BSD-3-Clause, CC0-1.0, MIT, MIT-0, Unlicense, WTFPL are collected; forks, mirrors, templates, repositories that share a root commit with another and repositories on the opt-out list are excluded.
• Commits. Merge commits, commits by bot accounts, version bumps and formatting-only commits are dropped. File changes are filtered by extension, by content (hunk, diff and file size, generated files) and by a path deny list for machine-written files such as lockfiles and IDE state.
• Edits. Each commit is split into atomic edits arranged in an action graph. Replaying a path through the graph reconstructs every intermediate state of the files. The default splitter orders the edits of a file from top to bottom and the files of a commit alphabetically, so a history is this replay order, not the developer's typing order. One point is sampled per commit with a seed derived from the commit, so revisions of the dataset share rows: the edits before the point form the history, the next edit is the target, and the caret is placed without looking at the target. A point without history is redrawn, and a commit with a single edit yields no row.
• Quality. Rule-based filters judge the target and the history (output size, number of hunks, import-only edits, whether the target shares an identifier with the history). On the train split, an LLM grader additionally rejects edits that are not motivated by the history, that break semantics, that are cosmetic, or that revert the history. Validation and test rows are not graded.
• Screening. Every example is scanned for credentials and private keys; examples holding a likely credential are dropped and personal email addresses in code are replaced by placeholders.

Configurations

Config	Contents
trajectories	the examples (train 83,293, validation 32,513, test 32,079 rows)
context-full-line-rag	retrieved code snippets for each example, joined on trajectory_id

Quick start

from datasets import load_dataset

examples = load_dataset("JetBrains/nessie-set")  # the default config: train, validation and test
contexts = load_dataset("JetBrains/nessie-set", "context-full-line-rag")

Context rows join the examples on trajectory_id.

Item format

trajectories columns

Column	Type	Description
trajectory_id	string	Stable ID of the example across revisions; join key of the context table.
inputs	TrajectorySnapshot	The model input: current file state and edit history.
outputs	Action	The ground-truth next edit to predict (always a rewrite).
language	string	Language of the edited file (e.g. Python, Markdown).
repo_language	string	Primary language of the repository.
repo_metadata	RepoMetadata	Source repository, commits, author and license.
source_metadata	SourceMetadata	source is commits (mined) or synthetic (generated).
source_action_graph_id	string	ID of the commit's edit graph the example was sampled from.
trajectory_index	int	Position of the sampled point in its trajectory.
trajectory_length	int	Number of edits in the trajectory.

inputs - TrajectorySnapshot

{
  "file":    FileContext,      // the file being edited, split at the caret
  "history": [ Rewrite ]       // recent edits, in trajectory order
}

inputs.file - FileContext

The current file content, split at the caret position. The caret is placed without looking at the target edit.

{
  "filepath": string,   // repo-relative path
  "prefix":   string,   // file content before the caret
  "suffix":   string    // file content after the caret
}

Full file content is prefix + suffix.

inputs.history[] and outputs - Rewrite

A history item is a completed edit: a region of a file was replaced (its original text became new). The history is in trajectory order: for commit-mined rows the replay order of the commit (edits top to bottom within a file, files alphabetically), not the developer's typing order; for generated rows the order the generator produced them. outputs is the next such edit, the one to predict.

{
  "type": "rewrite",
  "filepath": string,
  "span":       LineSpan,   // lines replaced, in the pre-edit file: { "start": int, "end_exclusive": int }
  "span_after": LineSpan,   // lines occupied by the replacement, in the post-edit file
  "original": string,       // text before
  "new":      string        // text after
}

Minimal example - a return type was changed from int to long:

{
  "type": "rewrite",
  "filepath": "src/Calc.java",
  "span":       { "start": 4, "end_exclusive": 5 },
  "span_after": { "start": 4, "end_exclusive": 5 },
  "original": "    public int total() {",
  "new":      "    public long total() {"
}

The rows carry no in-progress (partially typed) edits; training-time augmentation produces those from rewrite targets.

repo_metadata - RepoMetadata

{
  "repo_id":       string,          // "owner/name", e.g. "JetBrains/skiko"
  "commit":        string,          // commit the file state comes from
  "target_commit": string,          // commit that introduced the target edit
  "author_login":  string | null,   // GitHub login of the target commit's author; null when GitHub links no account
  "license": {                      // the repository's license as classified by GitHub at `commit`
    "spdx_id": string | null,       // e.g. "MIT"
    "name":    string | null,
    "url":     string | null,
    "path":    string | null        // the license file in the repository
  }
}

context-full-line-rag columns

Column	Type	Description
trajectory_id	string	The example the snippets belong to.
status	string	ok when retrieval succeeded.
context	[ContextItem]	Retrieved snippets, best first.

{
  "content":  string,        // the retrieved code snippet
  "filepath": string | null, // file the snippet came from
  "type":     string,        // kind of item, set by the retrieval strategy
  "score":    float          // relevance score
}

Snippets are drawn from source files near the edited file in the repository at the row's commit, split into overlapping multi-line chunks and scored against the edited file; the highest-scoring chunks are kept. Retrieval never reads the target edit.

Statistics and attribution

Figure	Value
Examples	147,885
Repositories	9,146
Languages	17
Distinct GitHub accounts credited	27,376
Share of examples in the 10 largest repositories	0.4%
Share of examples in the 100 largest repositories	3.2%
Median code lines per repository	11,746 (p10 1,374, p90 112,418)
Opt-out list version	1

Commit examples credit the GitHub account linked to the commit that introduced the target edit (repo_metadata.author_login); commits GitHub links to no account are credited as "unknown". NOTICES.md lists each repository, its license and the GitHub usernames of the authors of the commits whose edits appear here. No email addresses are included.

Rows per split

Split	Rows
train	83,293
validation	32,513
test	32,079

Rows per language

Rows per repository license

License	Repositories	Rows
MIT	5,659	88,053
Apache-2.0	3,219	55,208
BSD-3-Clause	214	3,679
BSD-2-Clause	54	945

Intended use

NESsie-set is built to train and evaluate models that suggest the next edit in an editor from the developer's recent edits. The train split is filtered by the LLM grader; validation and test are not, so they reflect the raw distribution of commit edits that pass the rule-based filters.

Splits are assigned per repository, so train, validation and test share no repository. All rows come from public GitHub, so a model pretrained on public code may have seen the post-edit files; NOTICES.md lists every repository for decontamination.

License

This dataset is released under the Apache License 2.0 (see LICENSE).

The dataset's structure, schema, curation, and derived labels are original work by JetBrains and are covered by this license.

The dataset also contains source code excerpts drawn from publicly available open-source repositories. Each excerpt retains the license of its originating repository. All originating licenses are permissive (Apache-2.0, BSD-2-Clause, BSD-3-Clause, CC0-1.0, MIT, MIT-0, Unlicense, WTFPL); no copyleft-licensed content is included. The originating repository and license for each example are recorded in that example's metadata (repo_metadata). A full list of included repositories, their licenses, and their authors is provided in NOTICES.md; notices/<owner>/<repository>.txt reproduces the NOTICE file of each repository that has one.

If you redistribute this dataset or derivatives of it, you are responsible for complying with the terms of each excerpt's originating license — including attribution — in addition to the Apache License 2.0 terms covering JetBrains' own contribution.

If you believe your code has been included in error, or would like it removed, contact legal@jetbrains.com. Removals take effect in the next published version.

Personal and sensitive information

Rows are screened for credentials before publication, and personal email addresses in code are replaced by placeholders. GitHub usernames are included for attribution.

Version

NESsie-set 1.0, issued from internal revision v20 (the label in the Hub commit history).