Eclipse Xtext was our standard toolkit for domain-specific languages (DSLs) throughout the 2010s. In 2021 we started Eclipse Langium to bring the same approach to TypeScript and web-based tools. Both frameworks serve the vast majority of language projects well.
In some projects we hit hard limits. Once a workspace reaches several megabytes of source text, or contains very large files, editor features such as completion and validation respond slowly and memory consumption grows sharply. There are various reasons for that, a lot of which are deeply ingrained in the architecture and platform of the specific frameworks, such as a lack of shared-memory parallelization.
As a consequence, we started a new implementation in Go, which is specifically designed for high-performance language engineering. The result is Fastbelt, announced in March 2026 and released as version 0.1 in June 2026. It carries over proven concepts from Xtext and Langium, such as the grammar language and automatic cross-reference resolution, and complements both frameworks for performance-critical use cases.
Eclipse Fastbelt provides a toolkit for implementing formal languages, in particular domain-specific languages (DSLs), on the Go platform. High performance and low resource consumption on large workspaces are the primary design goals. The scope includes:
- A grammar language for defining concrete and abstract syntax, with generators that derive lexers, parsers, and type definitions from it
- Infrastructure for processing language documents: cross-reference resolution, scoping, indexing, validation, type checking, and parallel workspace builds, with customization points for all of these
- A library for using language implementations programmatically, e.g. in command-line tools, code generators, and automation services
- Exposure of language services through standard protocols, such as the Language Server Protocol (LSP) for editors and the Model Context Protocol (MCP) for AI agents, and further support for AI-assisted work with languages built on the toolkit
- Delivery of language implementations as native executables and for web environments via WebAssembly (WASM)
- Supporting tools for language developers: command-line interface, project scaffolding, testing utilities, editor support for the grammar language, examples, and documentation
Eclipse Fastbelt does not include text editing functionality, which is left to editors that support LSP. General-purpose tooling for the Go programming language, AI models, and general-purpose AI agents are also out of scope.
Eclipse Fastbelt is a toolkit for implementing domain-specific languages (DSLs) and other formal languages in Go. It is built for high performance on large workspaces and large files.
A DSL lets domain experts describe data, rules, or behavior in a concise text notation that software can check and process automatically. Users of such a language expect the same editor support as for programming languages: code completion, navigation, and immediate error feedback. This becomes hard to deliver when a workspace holds thousands of files or single files of several megabytes. Language tooling then tends to become slow and memory-hungry, and the responsiveness of editors starts to suffer dramatically.
Eclipse Fastbelt addresses this in its architecture: Language primitives such as tokens, AST nodes and cross-references are implemented using techniques that prevent costly memory allocations. Additionally, parsing, reference resolution, and validation run in parallel on multiple CPU cores, based on thread-safe data structures. Together, this ensures that Fastbelt is utilizing the available hardware as much as possible. In benchmarks, workspace builds are up to two orders of magnitude faster than with comparable frameworks.
The starting point of a Fastbelt project is a grammar definition, similar to Eclipse Xtext and Eclipse Langium. It describes the text syntax of the language together with the structure of the resulting abstract syntax tree (AST). From the grammar, Fastbelt generates Go code for the lexer, the parser, the AST types, and the resolution of cross-references between language elements, also across files. Language-specific behavior such as validation rules, scoping, interpreters, or code generators is added in plain Go code.
Fastbelt includes a language server based on the Language Server Protocol (LSP) with default implementations of code completion, go to definition, find references, hover, outline, workspace symbols, and folding. This makes a language available in Eclipse Theia, VS Code, and any other LSP-capable editor. The same language implementation can also be used as a library, e.g. in command-line tools and automation services.
Eclipse Fastbelt complements Eclipse Langium, which remains the first choice for most DSL projects and for web-based tools in the TypeScript ecosystem. Fastbelt is intended for cases where scale and performance are the central challenge.
Eclipse Fastbelt completes the range of language engineering frameworks at the Eclipse Foundation. Eclipse Xtext serves Java and EMF-based tools, Eclipse Langium serves TypeScript and web-based tools, and Eclipse Fastbelt adds an option for workspaces that exceed what these two can handle efficiently. All three share the same grammar-based approach, so users who reach the limits of one framework find a familiar alternative within the same community. Like Langium, Fastbelt connects to editors through the Language Server Protocol, so languages built with it work in Eclipse Theia and other tools of the Eclipse Cloud Development project, on the desktop as well as in the browser via WebAssembly. Fastbelt also gives Go developers an entry point into the Eclipse language engineering ecosystem.
A language framework is a long-term dependency: a company that builds its DSL on Fastbelt commits to it for many years. Vendor-neutral governance makes that commitment reasonable. With the Eclipse Foundation holding the trademark, a defined IP process, and open rules for contributions and committer elections, adopters can rely on the project independently of any single company and take part in its development on equal terms. We expect this to increase adoption and to attract contributors from other organizations, as it has for Eclipse Theia, Eclipse Sprotty, and Eclipse Langium, which TypeFox moved to the Eclipse Foundation in the past. Fastbelt has already received contributions from outside TypeFox, and we want these contributors to have a clear path to becoming committers.
The first goal is to make Fastbelt ready for production use. We plan to add the following functionality:
- Lexer modes for languages that need context-dependent tokenization, e.g. for template strings
- Grammar syntax for infix operators, which improves the readability of grammars as well as parser performance
- Support for multiple languages within a single language server
- Handling of file changes that happen outside the editor
- Further LSP features, in particular semantic highlighting and formatting
- An integration with the Model Context Protocol (MCP) and further tooling that makes languages built with Fastbelt accessible to AI agents, building on our experience with Langium AI
To grow the community, we will present Fastbelt at conferences, including the Eclipse Foundation's Open Community Experience (OCX), and publish articles, documentation, and example languages. The existing Eclipse Xtext and Eclipse Langium communities are a natural audience, since the concepts carry over directly. All development is discussed in the open on GitHub, and we will support regular contributors on their way to becoming committers.
The initial contribution can be transferred to an Eclipse Foundation-managed GitHub organization as soon as the project has been provisioned. After the transfer, we will set up the project website at eclipse.dev/fastbelt and change the Go module path from typefox.dev/fastbelt to eclipse.dev/fastbelt. The first release under Eclipse governance follows once this change and the IP review of the initial contribution are complete. Development continues without interruption during the migration. Subsequent releases follow the roadmap described under Future Work, leading up to a production-ready version.
The initial contribution consists of one repository: https://github.com/TypeFox/fastbelt. It contains the complete framework as released in version 0.1 (June 2026) and the development since then:
- Core packages for lexing, parsing, AST representation, cross-reference linking, workspace management, and the LSP server
- The grammar language, which is implemented with Fastbelt itself via a bootstrapping technique, and the code generator
- The fastbelt command-line tool for code generation and project scaffolding
- Utilities for testing language implementations
- Two example languages (arithmetics and state machine) and three VS Code extensions: one for the grammar language and one for each example
The framework is written in Go, the VS Code extensions in TypeScript. The copyright is held by TypeFox GmbH, and the license has been MIT from the beginning. The vast majority of the code was written by TypeFox employees.
The community around Fastbelt is still young. The repository has about 30 stars on GitHub and has received its first contributions from outside TypeFox. The VS Code extension for the grammar language is published on the Visual Studio Marketplace, and Fastbelt was presented at the Open Community Experience (OCX) 2026.
Third-party Go libraries:
- github.com/spf13/cobra (Apache-2.0)
- golang.org/x/exp/jsonrpc2 (BSD-3-Clause)
- typefox.dev/lsp (BSD-3-Clause): Go types for the Language Server Protocol, maintained by TypeFox at https://github.com/TypeFox/go-lsp and derived from the protocol package of gopls (Copyright The Go Authors)
- github.com/stretchr/testify (MIT), used in tests only
- Transitive: spf13/pflag (BSD-3-Clause), inconshreveable/mousetrap (Apache-2.0), golang.org/x/exp/event (BSD-3-Clause), golang.org/x/xerrors (BSD-3-Clause)
- Transitive, tests only: davecgh/go-spew (ISC), pmezard/go-difflib (BSD-3-Clause), gopkg.in/yaml.v3 (MIT and Apache-2.0)
Third-party npm packages of the VS Code extensions: vscode-languageclient (MIT). Build tools: typescript (Apache-2.0), esbuild (MIT), @vscode/vsce (MIT), ovsx (EPL-2.0), shx (MIT), @types/node and @types/vscode (MIT).
- Log in to post comments