# What Programming Language Is llmfit Written In?

> Discover what programming language powers llmfit. This powerful tool is built exclusively in Rust, utilizing its 2024 edition for CLI, TUI, GUI, and web dashboard.

- Repository: [Alex Jones/llmfit](https://github.com/AlexsJones/llmfit)
- Tags: getting-started
- Published: 2026-09-13

---

**llmfit is written entirely in Rust**, using the 2024 edition of the language across a Cargo workspace that powers its CLI, TUI, desktop GUI, and embedded web dashboard.

AlexsJones/llmfit is an open-source hardware compatibility analyzer for Large Language Models. Every component—from low-level system detection to the interactive terminal interface—is implemented in Rust and compiled with the stable toolchain, ensuring cross-platform portability without requiring nightly features.

## Rust Workspace Architecture

The project follows a **Cargo workspace** pattern defined in the root [`Cargo.toml`](https://github.com/AlexsJones/llmfit/blob/main/Cargo.toml). This structure separates concerns into three distinct crates while sharing dependencies and version information.

### Three-Crate Structure

The workspace members are organized as follows:

- **llmfit-core** – The shared library located in [`llmfit-core/src/lib.rs`](https://github.com/AlexsJones/llmfit/blob/main/llmfit-core/src/lib.rs) that handles hardware detection, model catalog management, fit analysis, and benchmarking.
- **llmfit-tui** – The main binary crate that provides the command-line interface, terminal UI, and Axum HTTP server, with its entry point at [`llmfit-tui/src/main.rs`](https://github.com/AlexsJones/llmfit/blob/main/llmfit-tui/src/main.rs).
- **llmfit-desktop** – A Tauri-based desktop application wrapping the core library for native GUI experiences, configured in [`llmfit-desktop/Cargo.toml`](https://github.com/AlexsJones/llmfit/blob/main/llmfit-desktop/Cargo.toml).

The workspace configuration explicitly sets the resolver to version 3 and pins the package version to 1.1.15:

```toml
[workspace]
members = ["llmfit-core", "llmfit-tui", "llmfit-desktop"]
default-members = ["llmfit-core", "llmfit-tui"]
resolver = "3"

```

## Core Library Implementation

The **llmfit-core** crate contains the domain logic and is deliberately free of UI concerns. This allows the same Rust code to power the CLI, web API, and desktop interfaces.

### Hardware Detection and Model Management

System querying is implemented in [`llmfit-core/src/hardware.rs`](https://github.com/AlexsJones/llmfit/blob/main/llmfit-core/src/hardware.rs) using the `sysinfo` crate for cross-platform CPU, RAM, and GPU detection. The model catalog is defined in [`llmfit-core/src/models.rs`](https://github.com/AlexsJones/llmfit/blob/main/llmfit-core/src/models.rs), which loads the embedded [`hf_models.json`](https://github.com/AlexsJones/llmfit/blob/main/hf_models.json) and defines the `LlmModel` struct.

Fit calculations and throughput estimates reside in [`llmfit-core/src/fit.rs`](https://github.com/AlexsJones/llmfit/blob/main/llmfit-core/src/fit.rs), handling the scoring logic that determines whether a given LLM will run on detected hardware.

### Safety and Error Handling

The codebase adheres to **safety-first** Rust practices:

- **Zero `unsafe` blocks** – No unsafe code is used anywhere in the project.
- **Robust error handling** – The code avoids `.unwrap()` on user-provided paths, instead using descriptive `expect()` messages or proper `Result` propagation.
- **Zero-cost abstractions** – Heavy computational work is done in pure Rust without runtime overhead.

## Command-Line and Terminal Interface

The **llmfit-tui** crate provides multiple interaction modes through a unified Rust binary.

### CLI and Output Formatting

The entry point at [`llmfit-tui/src/main.rs`](https://github.com/AlexsJones/llmfit/blob/main/llmfit-tui/src/main.rs) parses arguments using standard Rust CLI patterns and dispatches to subcommands. Classic table output and JSON serialization are handled in [`llmfit-tui/src/display.rs`](https://github.com/AlexsJones/llmfit/blob/main/llmfit-tui/src/display.rs), supporting both human-readable and machine-readable formats.

### Interactive TUI and Web Server

The terminal user interface is implemented in [`llmfit-tui/src/tui_ui.rs`](https://github.com/AlexsJones/llmfit/blob/main/llmfit-tui/src/tui_ui.rs) using **ratatui** and **crossterm** for cross-platform terminal manipulation. The same crate exposes an HTTP API via the Axum framework, serving the embedded React dashboard (defined in [`llmfit-web/src/main.jsx`](https://github.com/AlexsJones/llmfit/blob/main/llmfit-web/src/main.jsx)) when running the `serve` subcommand.

## Desktop Application

The **llmfit-desktop** crate provides a native GUI wrapper around the core library. Built with **Tauri**, this Rust-based desktop application compiles to platform-specific binaries while reusing the exact same hardware detection and fit analysis logic defined in `llmfit-core`.

## Building and Running llmfit

Because llmfit is a standard Rust project, you build it using Cargo. The following commands demonstrate common usage patterns after cloning the repository:

1. **Show detected hardware:**

```bash
cargo run -- --cli system --json

```

2. **List available models sorted by release date:**

```bash
cargo run -- --cli list --sort date --json

```

3. **Find models that fit your machine:**

```bash
cargo run -- --cli fit --perfect -n 5 --json

```

4. **Start the HTTP API and dashboard server:**

```bash
cargo run -- serve --host 0.0.0.0 --port 8787

```

All compilation targets the stable Rust toolchain, producing a single binary that runs on Linux, macOS, and Windows without modification.

## Summary

- **llmfit is a Rust project** using the 2024 edition across all components.
- The **Cargo workspace** contains three crates: `llmfit-core` (library), `llmfit-tui` (CLI/TUI/web), and `llmfit-desktop` (GUI).
- Core logic resides in [`llmfit-core/src/lib.rs`](https://github.com/AlexsJones/llmfit/blob/main/llmfit-core/src/lib.rs) with hardware detection in [`hardware.rs`](https://github.com/AlexsJones/llmfit/blob/main/hardware.rs) and model fitting in [`fit.rs`](https://github.com/AlexsJones/llmfit/blob/main/fit.rs).
- The project uses **zero unsafe code** and relies on crates like `sysinfo`, `ratatui`, and `axum`.
- It compiles with stable Rust and runs natively on all major platforms.

## Frequently Asked Questions

### Is llmfit written in Python or Rust?

llmfit is written entirely in **Rust**, not Python. While many machine learning tools rely on Python for model inference, llmfit focuses on hardware detection and compatibility analysis, tasks for which Rust provides better performance and distribution characteristics through single-binary deployment.

### What Rust edition does llmfit use?

The project uses the **2024 edition** of Rust, as specified in the workspace [`Cargo.toml`](https://github.com/AlexsJones/llmfit/blob/main/Cargo.toml). This edition provides the latest language features while maintaining compatibility with the stable toolchain, meaning you do not need nightly Rust to compile the project.

### Does llmfit contain any unsafe Rust code?

No. According to the source code analysis, llmfit contains **zero `unsafe` blocks**. The developers explicitly avoid unsafe code, relying instead on Rust's ownership system and crates like `sysinfo` for safe cross-platform system access. Error handling uses `Result` types rather than panicking on invalid user input.

### Can I build llmfit on Windows, macOS, and Linux?

Yes. Because llmfit is written in standard Rust with no platform-specific dependencies beyond what the `sysinfo` and `crossterm` crates abstract away, it compiles and runs on any platform supported by the Rust compiler. The `cargo build` command produces native binaries for all three operating systems without code changes.