Open-source project
FuelLabs/fuel-core avatar
FuelLabs/fuel-core

fuel-core: A Rust Full Node for the Fuel v2 Network, Warts and All

Rust full node implementation of the Fuel v2 protocol.

56,751 stars2,873 forksRustApache-2.0

At a glance

What is it?
FuelLabs/fuel-core is the Rust implementation of the Fuel v2 protocol node, offering instant block production and a GraphQL API. This review covers its build process and operational quirks.
Who is it for?
Adopt fuel-core if you need a node for the Fuel Ignition or testnet networks and you are comfortable with Rust tooling and RocksDB quirks. Do not use it if you need a node that supports a different consensus model.
Can I use it commercially?
Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository received new commits within the last day.
What is it written in?
Mainly Rust, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • FuelLabs/fuel-core56,751 ★ · -149
Star history
Repository2026-08-182026-11-15
FuelLabs/fuel-core56.9k56.8k

-149 Stars in the last 89 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

What fuel-core Actually Does

fuel-core is the official Rust implementation of the Fuel v2 protocol, a full node that participates in the Fuel Ignition network, the testnet, and the devnet. The README positions it as the 'Fuel client implementation', and the version table shows that all three networks currently run version 0.48.1. This is not a generic blockchain framework; it is a specific node for a specific chain. The primary audience is node operators who want to run their own infrastructure for Fuel, or developers who need a local node to test smart contracts and transactions against a real Fuel chain. The node exposes a GraphQL service, which is the main interface for submitting transactions and querying state. It also performs instant block production, meaning it does not wait for a consensus round but produces blocks as soon as transactions arrive, at least in its default configuration.

Instant Block Production and the GraphQL Endpoint

The transaction executor in fuel-core currently performs instant block production, according to the README. The README shows that you can disable this with the flag `--poa-instant=false`, which suggests the node supports a proof-of-authority style mode where block production is turned off. The GraphQL service is available at `/v1/graphql` and expects a mutation called `submit` that takes a transaction in hex encoded binary format. The schema is generated after building and can be found at `crates/client/assets/schema.sdl`. This is a concrete, testable interface, so inspect the generated file to see all available queries and mutations.

Building from Source: More Than Just cargo build

Building fuel-core from source is not a simple `cargo build`. The README lists system requirements that include clang, cmake, pkg-config, and build-essential on Debian, with specific commands for MacOS, Debian, and Arch. You also need the `wasm32-unknown-unknown` target installed via `rustup target add wasm32-unknown-unknown`. The recommended build command for development is `cargo xtask build`, which runs `cargo build` and also regenerates the GraphQL schema. The README shows a `make build` command for building the node binary, which the Makefile maps to `cargo build-fuel-core-bin-release`. This is a friction point: if you are used to a simple `cargo build`, you will need to read the Makefile and the xtask source to understand what extra steps are involved. The build process is clearly tailored for contributors, not for end users who just want to run a node, since the README points you to pre-compiled binaries for actual network participation.

Running a Node: Local vs Ignition

The README distinguishes between running a local network and running a node for the Ignition network. For local development, you clone the repo, build, and run `fuel-core run` with options like `--db-type in-memory` to avoid persistent state. The example log output shows that with `--db-type in-memory`, the node starts in 'Instant' block production mode and binds the GraphQL provider to 127.0.0.1:4000. For the Ignition network, the README points to external documentation. This is a gap: the README assumes you will follow external docs for mainnet node operation, but it does not provide the necessary flags or configuration for connecting to the Ignition network. The local node example uses version v0.18.1 in the log output, which is much older than the current v0.48.1, suggesting that the README examples may be outdated. You should verify the current flags with `fuel-core run --help` before relying on them.

Operational Pitfalls: Database Panics and File Descriptors

The README's troubleshooting section is honest about real failure modes. One is the outdated database error, where the node panics with a message about column families not being opened. The fix is to delete the local database with `rm -rf ~/.fuel/db`. This implies that database schema changes between versions are not automatically migrated, and you will need to reset your state manually. For a node operator, this is a significant operational cost, especially on a mainnet node where you would need to re-sync from genesis or a snapshot. Another pitfall is file descriptor limits on macOS, which can cause IO errors like 'Too many open files' or even a fatal runtime error because Rust cannot catch foreign exceptions from RocksDB. The README recommends `ulimit -n 10240` in the current shell, and suggests adding it to `~/.zshrc`. These are concrete, actionable warnings, but they also reveal that the node relies on RocksDB, which is a C++ library with its own resource requirements.

Configuration and Logging: RUST_LOG and Human Logging

The node relies on the `RUST_LOG` environment variable for log level control, which is standard for Rust applications using the `tracing` crate. You can also disable human-readable logging with `HUMAN_LOGGING=false`, which is useful for machine parsing. The README points to the `EnvFilter` examples in the tracing-subscriber documentation for syntax. This is a small but important detail: if you are running the node in production, you will need to set `RUST_LOG` appropriately to avoid log spam or to capture debug information. The `--snapshot` option is mentioned in the help output, allowing you to specify a snapshot for (re)genesis,.

Alternatives: Comparing to Other Node Implementations

The repository describes fuel-core as a Rust full node implementation of the Fuel v2 protocol. The GraphQL `submit` mutation takes a transaction type defined in the separate fuel-vm repository.

Editorial conclusion

Adopt fuel-core if you need a node for the Fuel Ignition or testnet networks and you are comfortable with Rust tooling and RocksDB quirks. Do not use it if you need a node that supports a different consensus model. Before committing, verify the exact version your target network runs (currently 0.48.1 for Ignition, testnet, and devnet), check the latest release notes for breaking changes, and test the in-memory database mode first to understand the block production behavior. The project is actively maintained with releases every few months, but the README's own troubleshooting section admits that outdated databases can panic on startup, so plan for manual db resets.

Frequently asked questions

How do I build fuel-core from source?

Clone the repository, install the system packages for your platform including clang and cmake, add the Rust target with rustup target add wasm32-unknown-unknown, and run make build, which calls cargo build-fuel-core-bin-release. Contributors are pointed at cargo xtask build instead, because it also regenerates the GraphQL schema for the client.

Which fuel-core version runs on the Fuel networks?

The network table in the project's documentation lists 0.48.1 for Fuel Ignition, Testnet and Devnet. The workspace Cargo.toml and the newest release tag are both at 0.48.3, published on 2026-08-27, so the version to run is the one your network expects rather than the newest tag.

What does fuel-core run --db-type in-memory do?

It starts a node whose state is not persisted, which the documentation describes as useful when you want a chain that does not survive between runs. Block production is instant by default and can be turned off with --poa-instant=false, and the --snapshot option chooses where genesis or re-genesis starts from, defaulting to a local testnet configuration.

Where is the fuel-core GraphQL endpoint and its schema?

The client is reached at the service endpoint /v1/graphql, and the schema is written to crates/client/assets/schema.sdl once you have built the workspace. The service expects a mutation named submit that receives a transaction in hex encoded binary format.

What licence does fuel-core use?

The workspace Cargo.toml declares license as BUSL-1.1 and the terms live in the LICENSE file at the repository root, while the repository metadata reports Apache-2.0, so the two disagree. The project documentation does not restate what those terms permit, so the file is the only statement of what you may do with the code.

Official sources

  1. Official README
  2. Project repository
  3. Release notes
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/fuellabs-fuel-core.svg)](https://hysenlabs.com/projects/fuellabs-fuel-core)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/fuellabs-fuel-core.svg)](https://hysenlabs.com/projects/fuellabs-fuel-core)

Was this useful?