Rust linux что это

Rust linux что это

Rust is a general-purpose, multi-paradigm, compiled programming language sponsored by Mozilla Research. It is designed to be a «safe, concurrent, practical language», supporting pure-functional, imperative-procedural, and object-oriented styles. The goal of Rust is to be a good language for creating highly concurrent and highly safe systems, and programming in the large. This has led to a feature set with an emphasis on safety, control of memory layout, and concurrency. Performance of idiomatic Rust is comparable to the performance of idiomatic C++.


Core language

Rust Core Library

The Rust Core Library is the dependency-free foundation of the Rust Standard Library. It interfaces directly with LLVM primitives, which allows Rust to be platform and hardware-agnostic. It is this integration with LLVM that allows Rust to obtain greater performance than equivalent C applications compiled with Clang, making Rust software designed with libcore lower level than C. It contains only basic platform-independent types such as Option , Result , and Iterator . Developers looking to target software for embedded platforms may forego the standard library with #![no_std] to exclusively use the no-batteries-included core library for smaller binary sizes and improved performance. However, using #![no_std] limits the amount of software support that you can get from the larger Rust community as a majority of libraries require the standard library.

Rust Standard Library

The Rust Standard Library provides the convenient high level abstractions by which a majority of portable Rust software is created with. It features convenient features such as the Vec and String types; a vast amount of methods for language primitives; a large number of standard macros; I/O and multithreading support; heap allocations with Box ; and many more high level features not available in the core library.

Release cycle

Rust follows a regular six-week release cycle, similar to the release cycle of Firefox. With each new release, the core and standard libraries are improved to support more platforms, improve performance, and stabilize new features for use with stable Rust.


The two main ways to install Rust are:

  • The Native installation, recommended if you only use rust for running or installing software made with Rust
  • The Rustup installation, recommended if you intend to program anything in Rust

Native installation

To install the latest stable version of Rust from the official Arch Linux software repository, install the rust package. This will install the rustc compiler and Cargo.

There is also a development version of the Rust compiler available from the AUR. Use rust-nightly-bin AUR for prebuilt generic binaries or rust-git AUR to build the compiler with system libraries.


The official and recommended method of installing Rust for the purpose of developing software is to use the Rustup toolchain manager, written in Rust.

The benefit of using the Rustup toolchain manager instead of the standalone prepackaged Rust in the software repository is the ability to install multiple toolchains (stable, beta, nightly) for multiple targets (windows, mac, android) and architectures (x86, x86_64, arm).

There are two choices for a Rustup installation, one is supported by Arch Linux via pacman, while the other is officially supported by Rust via their installation script.

Arch Linux package

rustup is available on the Arch Linux software repository. Note that rustup self update will not work when installed this way, the package needs to be updated by pacman.

This package has the advantage that the various Rust executables live in /usr/bin , instead of

/.cargo/bin , removing the need to add another directory to your PATH .

In order to install the toolchain, you need to tell rustup which version to use: stable or nightly .

Upstream installation script

Rustup is also available to download and install manually via rustup’s official web page.

Download the file with curl —proto ‘=https’ —tlsv1.3 -sSf -o , view it: less ./ , and run the script ./ to start rustup installation. The script makes PATH changes only to login shell configuration files. You need to source

/.cargo/env until you logout and login back into the system. To update rustup afterwards, run rustup self update .

The script installs and activates the default toolchain by default (the one used by the rust package), so there is no need to manually install it to start using Rust.

/.cargo/bin is in your PATH when you run rustup .


You might need to manually install a toolchain, e.g. stable , beta , nightly or 1.58.0 . You also need to do this if you want to use/test another toolchain.

Читайте также:  Запрос на обновление таблицы sqlite

You can now run the Rust commands by running, rustup run toolchain command . However, to use these commands directly, you need to activate the toolchain:

Check the installed Rust version using rustc -V :

Test your installation

Check that Rust is installed correctly by building a simple program, as follows:

You can compile it with rustc , then run it:

Cross compiling

Using rustup

You can easily cross-compile using Rustup. Rustup supports many cross-compile targets. A full list can be found running rustup target list .

For instance, if you want to install rust using the stable channel for Windows, using the GNU Compiler, you will need to do:

This will only install rust and its tools for your target architecture, but some additional tools might be needed for cross-compiling.


In this section, $ARCH is the target architecture (either x86_64 or i686 ). It will explain how to cross compile using rustup.

  1. Installmingw-w64-gcc
  2. Run rustup target add $ARCH-pc-windows-gnu to install rust standard library for your architecture.
  3. Finally, tell cargo where to find the MinGW-w64 gcc/ar by adding the following to your

Finally, you can cross compile for windows by passing the —target $ARCH-pc-windows-gnu to cargo:

Currently building executables using MinGW 6 and the toolchains installed by rustup is broken. To fix it, execute

where CHANNEL is the update channel ( stable , beta or nightly )

Unofficial packages

The unofficial repository archlinuxcn has rust-nightly and Rust std library for i686, ARM, ARMv7, Windows 32 and 64 so you can just install the one you want then enjoy cross-compiling. However, you have to find an ARM toolchain by yourself. For Windows 32bit targets, you will need to get a libgcc_s_dw2-1.dll (provided by mingw-w64-gcc ) to build and run.


Cargo, Rust’s package manager, is part of the rust package. The nightly version is available in the AUR as part of rust-nightly-bin AUR . If you use rustup , it already includes cargo.

Cargo is a tool that allows Rust projects to declare their various dependencies, and ensure that you will always get a repeatable build. You are encouraged to read the official guide.


To create a new project using Cargo:

This creates a directory with a default Cargo.toml file, set to build an executable.

Optimizing for native CPU platform

In order to instruct Cargo to always compile optimal code for your CPU platform, you can achieve this by adding a flag to

/.cargo/config . Please be aware that the resulting binaries can not be distributed for use on other computers, and might even fail on your own system if you decide to change your CPU in the future.

Find out which target platform is used by default on your installation:

In this example, we are using stable rust on the x86_64-unknown-linux-gnu platform.

Instruct Cargo to always compile code optimized for the native CPU platform:


Compilation times can be greatly reducing by using sccache ( sccache package). This will maintain a local cache of compiler artifacts, eliminating the need to recompile code that has not changed since the last time it was compiled.

To enable sccache, you can use RUSTC_WRAPPER environment variable:

Alternatively, add the following configuration to

IDE support


See for the recommended tools of the Rust project.

RLS provides a Language Server Protocol implementation for Rust, providing IDEs, editors, and other tools with information about Rust programs. It supports functionality such as ‘goto definition’, symbol search, reformatting, and code completion, and enables renaming and refactorings.

RLS is included in the rust package. To install RLS using rustup:


rust-analyzer is an experimental Language Server Protocol implementation for Rust which is meant to replace RLS.

It is available as the rust-analyzer package, and the latest Git version is available as rust-analyzer-git AUR .

rust-analyzer needs the source code of the standard library. If it is not present, rust-analyzer will attempt to install it automatically using rustup. To install the source code manually using rustup, run the following command:


Racer provides code completion support for editors and IDEs. It has been superseded by RLS (which uses Racer as a fallback).

It requires that you also install a copy of the Rust source code, which you can obtain in one of several ways:

  • With rustup: rustup component add rust-src
  • From the AUR: rust-src-gitAUR or rust-nightly-srcAUR , in this case you must set the RUST_SRC_PATH environment var.

After installing the source code, you can either use Cargo to install racer or obtain it from the repos ( rust-racer AUR ).


Clippy takes advantage of compiler plugin support to provide a large number of additional lints for detecting and warning about a larger variety of errors and non-idiomatic Rust.

Clippy is included in the rust package. To install it with rustup use:


Rustfmt is a tool to format Rust code according to the official style guidelines.

Rustfmt is included in the rust package. To install it with rustup use:


Atom support for Rust programming is provided by the ide-rust plugin (requires rustup).

IntelliJ IDEA

IntelliJ IDEA has a Rust plugin. The same plugin also works with CLion.

If using rustup, use rustup to download the source ( rustup component add rust-src ), and then select

/.rustup/toolchains/ /bin as the toolchain location.

If using Rust from the official Arch Linux software repository, select /usr/bin as the toolchain location and /usr/lib/rustlib/src/rust/library/ as the stdlib sources location.

Visual Studio Code

Visual Studio Code support for Rust can be obtained via rust-lang.rls extension (requires rustup). If using rust-analyzer, use the matklad.rust-analyzer extension instead.

Vim support for Rust can be obtained via the official rust.vim plugin, which provides file detection, syntax highlighting, formatting and support for the Syntastic syntax checking plugin. Many completion engines have Rust support, like coc (via the coc.rls plugin) and YouCompleteMe.


Emacs support for Rust can be obtained via the official rust-mode plugin.

Kate support for Rust is achieved using Language Server Protocol. It uses rust-analyzer by default; all you need to do is install it along with the Rust source.

GNOME Builder

GNOME Builder support for Rust is achieved using Language Server Protocol. It uses rust-analyzer by default; all you need to do is install it along with the Rust source.


Rust (Русский)

Rust — мультипарадигмальный компилируемый язык программирования общего назначения, сочетает парадигмы функционального и процедурного программирования с объектной системой, основанной на типажах. Rust гарантирует безопасную работу с памятью благодаря встроенной в компилятор системе статической валидации ссылок (borrow checker). Ключевые приоритеты языка: безопасность, скорость и параллелизм. Rust сопоставим по скорости и возможностям с C++/Си, однако даёт большую безопасность при работе с памятью, что обеспечивается встроенными в язык механизмами контроля ссылок.


Ядро языка

Rust Core Library

Rust Core Library — свободная от зависимостей основа стандартной библиотеки Rust. Она напрямую взаимодействует с примитивами LLVM, что позволяет Rust не зависеть от конкретных аппаратных и программных платформ. Именно эта интеграция с LLVM позволяет Rust получить производительность выше чем у эквивалентных приложений на C, скомпилированных с помощью Clang, что делает программы на Rust, разработанные с помощью libcore, более низкоуровневыми, чем на C. Она содержит только типы, не зависящие от платформы, такие как Option , Result и Iterator . Разработчики программ для встраиваемых систем могут отключить использование стандартной библиотеки с помощью #![no_std] и использовать только «безбатареечный» libcore для уменьшения размера скомпилированных программ и повышения производительности. Однако использование #![no_std] ограничивает объём поддержки, которую вы можете получить от сообщества Rust, поскольку большинство библиотек зависят от стандартной библиотеки.

Rust Standard Library

Стандартная библиотека Rust предоставляет удобные абстракции высокого уровня, с помощью которых создаётся большинство переносимых программ на Rust. Например, она содержит типы Vec и String ; огромное число методов для примитивов языка; много стандартных макросов; поддержка ввода-вывода и многопоточности; использование кучи (heap) с помощью Box ; и многие другие высокоуровневые возможности, не доступные в libcore.

Цикл выпуска

Rust следует шестинедельному циклу выпуска, похожему на цикл выпуска Firefox. С каждым новым выпуском ядро и стандартные библиотеки улучшаются для поддержки большего числа платформ, повышения производительности и стабилизации новых возможностей для использования со стабильной версией Rust.


Есть два варианта установки Rust, один из которых поддерживается Arch Linux, а другой официально поддерживается Rust.

Из репозитория

Для установки последней стабильной версии Rust из официальных репозиториев Arch Linux установите пакет rust . Он установит компилятор rustc и Cargo.

В AUR также доступна development-версия компилятора. Используйте rust-nightly-bin AUR для установки заранее скомпилированных файлов или rust-git AUR , чтобы собрать компилятор на своей системе.

С помощью Rustup

Официальный и рекомендумемый способ установки Rust для разработки ПО — с помощью инструмента Rustup, написанного на Rust.

Преимуществом использования Rustup вместо обычной установки Rust из репозитория является возможность установки нескольких toolchains (stable, beta, nightly) для нескольких целевых платформ (windows, mac, android) и архитектур (x86, x86_64, arm).

Официальный установочный скрипт

Скачайте скрипт установки командой curl —proto ‘=https’ —tlsv1.2 -sSf -o , просмотрите его: less ./ и запустите: ./ для установки. Этот скрипт вносит изменения в PATH только в настройках оболочки входа. Для применения изменений вам нужно перезайти или выполнить source

/.cargo/env для обновления PATH в текущей командной оболочке. Для обновления rustup в будущем запускайте rustup self update .

Скрипт устанавливает и активирует инструментарий (toolchain) по умолчанию (тот же, который используется пакетом rust ), поэтому нет необходимости устанавливать его вручную, чтобы начать использовать Rust.

/.cargo/bin добавился в переменную окружения PATH .

Пакет Arch Linux

В официальных репозиториях Arch Linux есть пакет rustup . Обратите внимание, что при установке с помощью этого пакета обновление с помощью rustup self update работать не будет, и для обновления rustup следует обновлять этот пакет с помощью pacman.

Преимущество этого пакета в том, что исполняемые файлы Rust находятся в /usr/bin вместо

/.cargo/bin , так что менять переменную окружения PATH не требуется.

Для установки инструментария задайте в rustup интересующую вас версию: stable или nightly .


Вам может потребоваться вручную установить инструментарий, например stable , beta , nightly или 1.58.0 . Это также необходимо сделать, если вы хотите использовать/тестировать другой инструментарий.

Теперь вы можете запускать команды Rust, выполняя rustup run toolchain command . Однако, чтобы использовать эти команды напрямую, необходимо активировать инструментарий:

Проверим версию Rust с помощью rustc -V :

Проверка после установки

Давайте убедимся, что Rust установился корректно, написав простую программу:

Затем скомпилируйте её с помощью rustc , введя это:


С помощью rustup

Использовать кросс-компиляцию с rustup очень легко. Он поддерживает очень много целевых платформ. Полный их список можно увидеть с помощью команды rustup target list .

Например, если вы хотите использовать stable Rust для Windows с компилятором GNU, сделайте следующее:

Эта команда установит только rust и инструменты для вашей целевой платформы, и для кросс-компиляции нужно сделать ещё несколько вещей.


В этом разделе $ARCH будет целевой архитектурой ( x86_64 или i686 ).

  1. Установите пакет mingw-w64-gcc .
  2. Выполните rustup target add $ARCH-pc-windows-gnu чтобы установить стандартную библиотеку Rust для целевой архитектуры.
  3. Подскажите cargo, где искать MinGW-w64 gcc/ar добавлением следующих параметров в

/.cargo/config (создайте файл, если он отсутствует):

Теперь вы можете выполнять кросс-компиляцию для Windows, указывая дополнительный аргумент —target $ARCH-pc-windows-gnu при вызове cargo:

В настоящее время сборка исполняемых файлов с использованием MinGW 6 и инструментария, установленного через rustup, сломана. Чтобы исправить это, выполните

где CHANNEL это канал обновлений ( stable , beta или nightly )

Неофициальные пакеты

Неофициальный репозиторий archlinuxcn содержит rust-nightly и стандартную библиотеку Rust для i686, ARM, ARMv7, Windows 32 и 64, и вы можете просто установить то, что вам нужно, и использовать кросс-компиляцию. Тем не менее вам нужно найти ARM toolchain самостоятельно. Для Windows 32bit вам нужно получить libgcc_s_dw2-1.dll (предоставляется пакетом mingw-w64-gcc ) для сборки и запуска.


Cargo — система сборки и менеджер пакетов для Rust. Он является частью пакета rust . Версия nightly доступна в AUR: rust-nightly-bin AUR . Если у вас rustup , то он уже содержит в себе cargo.

Cargo помогает работать с зависимостями вашего проекта, скачивая их из своего хранилища или стороннего Git репозитория. Также он позволяет убедиться, что вы всегда будете получать повторяемые сборки. Рекомендуем прочитать официальное руководство.


Для создания нового проекта с помощью Cargo:

Эта команда создаст директорию с файлом Cargo.toml по умолчанию и настроит сборку в исполняемый файл.

Оптимизация для текущей платформы

Чтобы Cargo всегда компилировал оптимальный код для вашего текущего процессора, добавьте флаг в

/.cargo/config . Имейте в виду, что полученные двоичные файлы не должны распространяться для использования на других компьютерах и могут перестать работать даже на вашей собственной системе, если вы решите сменить процессор в будущем.

Узнайте, какая целевая платформа используется по умолчанию в вашей установке:

В данном примере используется stable rust на платформе x86_64-unknown-linux-gnu .

Настройка Cargo для компилирования кода, оптимизированного для текущей платформы:


Время компиляции можно сильно сократить, используя sccache (пакет sccache ). Он будет хранить локальный кэш артефактов компилятора, избавляя вас от необходимости перекомпилировать код, который не изменился с момента последней компиляции.

Чтобы включить sccache, можно использовать переменную окружения RUSTC_WRAPPER :

Также можно добавить настройку в

Поддержка в IDE


Список полезных инструментов можно посмотреть на

RLS реализует Language Server Protocol для Rust, предоставляя IDE, редакторам и другим инструментам информацию о программах на Rust. Он поддерживает ‘goto definition’, поиск символов, переформатирование и автодополнение кода, а также позволяет осуществлять переименование и рефакторинг.

RLS входит в состав пакета rust . Чтобы установить RLS с помощью rustup:


rust-analyzer — это экспериментальная реализация Language Server Protocol для Rust, которая призвана заменить RLS.

Она доступна в виде пакета rust-analyzer , а последняя Git-версия доступна как rust-analyzer-git AUR .

rust-analyzer нуждается в исходном коде стандартной библиотеки. Если его нет, rust-analyzer попытается установить его автоматически с помощью rustup. Чтобы установить исходный код вручную с помощью rustup, выполните следующую команду:


Racer предоставляет поддержку автодополнения кода для редакторов и IDE. Он был заменён на RLS (который использует Racer в качестве запасного варианта).

Для этого требуется также установить копию исходного кода Rust, которую вы можете получить одним из нескольких способов:

  • С помощью rustup: rustup component add rust-src
  • Из AUR: rust-src-gitAUR или rust-nightly-srcAUR , в этом случае вы должны установить переменную окружения RUST_SRC_PATH .

После установки исходного кода вы можете использовать Cargo для установки racer или получить его из репозиториев ( rust-racer AUR ).


Clippy использует поддержку плагинов компилятора в Nightly-сборках Rust, чтобы обеспечить большое количество дополнительных проверок для обнаружения и предупреждения о более широком разнообразии ошибок и неидиоматическом Rust.

Clippy входит в состав пакета rust . Чтобы установить Clippy с помощью Rustup:


Rustfmt — инструмент для форматирования кода Rust в соответствии с официальным руководством по стилю.

Rustfmt входит в состав пакета rust . Чтобы установить с помощью Rustup:


Atom поддерживает программирование на Rust с помощью модуля ide-rust (требуется rustup).

IntelliJ IDEA

В IntelliJ IDEA имеется Rust plugin. Этот плагин также работает с CLion. При настройке toolchain используйте rustup для загрузки исходников ( rustup component add rust-src ), а затем выберите

/.rustup/toolchains/ /bin в качестве расположения toolchain. При установке Rust из официальных репозиториев Arch Linux выберите /usr/bin в качестве каталога toolchain и /usr/lib/rustlib/src/rust/library/ в качестве каталога, содержащего исходные коды стандартной библиотеки.

Visual Studio Code

В Visual Studio Code поддержка Rust может быть получена через официальное дополнение rust-lang.rls (требуется rustup). Если вы используете rust-analyzer, вместо этого расширения установите matklad.rust-analyzer.

В Vim поддержка Rust может быть получена через официальный плагин rust.vim, который предоставляет обнаружение файлов, подсветку синтаксиса, форматирование и поддержку плагина проверки синтаксиса Syntastic. Многие механизмы автодополнения имеют поддержку Rust, например coc (через плагин coc.rls) и YouCompleteMe.


В Emacs поддержка Rust может быть получена через официальный rust-mode плагин.

Поддержка Rust в Kate реализуется через Language Server Protocol. По умолчанию используется rust-analyzer; всё, что вам нужно, — это установить его вместе с исходниками Rust.

GNOME Builder

Поддержка Rust в GNOME Builder реализуется через Language Server Protocol. По умолчанию используется rust-analyzer; всё, что вам нужно, — это установить его вместе с исходниками Rust.


Поделиться с друзьями