(https://github.com/rust-unofficial/awesome-rust)
Email
from https://github.com/nrc/rustw
A curated list of Rust code and resources, inspired by other awesome lists.
If you want to contribute, please read this.
Table of Contents
- Applications written in Rust
- Development Tools
- Libraries
- Astronomy
- Asynchronous
- Audio
- Authentication
- Bioinformatics
- Caching
- Cloud
- Command-line argument parsing
- Command-line interface
- Compression
- Computation
- Concurrency
- Cryptography
- Database
- Data structures
- Date and time
- Distributed Systems
- Encoding
- Filesystem
- Game development
- Games
- Geospatial
- Graphics
- GUI
- Image processing
- Machine learning
- Markup language
- Mobile
- Network programming
- Parser
- Platform specific
- Template engine
- Text processing
- Text rendering
- Virtualization
- Web programming
- Resources
- License
Applications written in Rust
See also Friends of Rust (organizations running Rust in production).
- azerupi/mdBook — a command line utility to create books from markdown files
- bluejekyll/trust-dns — a DNS-server
- BurntSushi/xsv — a fast CSV command line tool (slicing, indexing, selecting, searching, sampling, etc.)
- dlecan/generic-dns-update — a tool to update DNS zonefiles with your IP address
- Factotum — A system to programmatically run data pipelines
- Fractalide — Flow-based Programming environment.
- imjacobclark/Herd — an experimental HTTP load testing application
- jedisct1/flowgger — a fast, simple and lightweight data collector
- kbknapp/docli — a command line utility for managing DigitalOcean infrastructure
- MaidSafe — a decentralized platform.
- qmx/limonite — static blog/website generator
- Servo — a prototype web browser engine
- Virtualization
- tailhook/vagga — a containerization tool without daemons
- Database
- pingcap/tikv — a distributed KV database in Rust
- seppo0010/rsedis — a Redis reimplementation in Rust
- Emulators [emulator]
- Commodore 64
- Gameboy
- NES
- Playstation
- ZX Spectrum
- Games, see also Games Made With Piston.
- lifthrasiir/angolmois-rust — a minimalistic music video game which supports the BMS format
- swatteau/sokoban-rs — a Sokoban implementation
- Zone of Control — a turn-based hexagonal strategy game
- rhex — hexagonal ascii roguelike
- Operating systems, see also A comparison of operating systems written in Rust
- System tools
- Aaronepower/tokei — counts the lines of code
- buster/rrun — a command launcher for Linux, similar to gmrun
- ogham/exa — a replacement for 'ls' written in Rust
- mmstick/systemd-manager — a systemd service manager written in Rust using GTK-rs.
- mmstick/tv-renamer — a tv series renaming application with an optional GTK3 frontend.
- uutils/coreutils — a cross-platform Rust rewrite of the GNU coreutils
- Text editors
Development tools
- Clippy [clippy] — Rust lints
- clog-tool/clog-cli — generates a changelog from git metadata (conventional changelog)
- dan-t/rusty-tags — create ctags/etags for a cargo project and all of its dependencies
- frewsxcv/crate-deps — generates images of dependency graphs for crates hosted on crates.io
- Racer — code completion for Rust
- rustfmt — a Rust code formatter
- Rustup — the Rust toolchain installer
Build system
- Cargo — the Rust package manager
- rsolomo/cargo-check [cargo-check] — a wrapper around
cargo rustc -- -Zno-trans
which can be helpful for running a faster compile if you only need correctness checks - kbknapp/cargo-count [cargo-count] — lists source code counts and details about cargo projects, including unsafe statistics
- pwoolcoc/cargo-do [cargo-do] — run multiple cargo commands in a row
- maxsnew/cargo-dot — generate graphs of a Cargo project's dependencies
- killercup/cargo-edit [cargo-edit] — allows you to add and list dependencies by reading/writing to your Cargo.toml file from the command line
- kbknapp/cargo-graph [cargo-graph] — updated fork of
cargo-dot
with additional features - imp/cargo-info [cargo-info] — queries crates.io for crates details from command line
- regexident/cargo-modules [cargo-modules] — A cargo plugin for showing a tree-like overview of a crate's modules.
- imp/cargo-multi [cargo-multi] — runs specified cargo command on multiple crates
- kbknapp/cargo-outdated [cargo-outdated] — displays when newer versions of Rust dependencies are available, or out of date
- sunng87/cargo-release [cargo-release] — tool for releasing git-managed cargo project, build, tag, publish, doc and push
- DanielKeep/cargo-script [cargo-script] — lets people quickly and easily run Rust "scripts" which can make use of Cargo's package ecosystem
- passcod/cargo-watch [cargo-watch] — utility for cargo to compile projects when sources change
- rsolomo/cargo-check [cargo-check] — a wrapper around
- CMake
- SiegeLord/RustCMake — an example project showing usage of CMake with Rust
Debugging
- GDB
- LLDB
- lldb_batchmode.py — allows to use LLDB in a way similar to GDB's batch mode.
Embedded
- Cross compiling
- japaric/rust-cross — everything you need to know about cross compiling Rust programs
- Raspberry Pi
- Ogeon/rust-on-raspberry-pi — instructions for how to cross compile Rust projects for the Raspberry Pi .
FFI
See also Foreign Function Interface and The Rust FFI Omnibus (a collection of examples of using code written in Rust from other languages).
- C
- crabtw/rust-bindgen — a Rust bindings generator
- Sean1708/rusty-cheddar — generates C header files from Rust source files
- Erlang
- hansihe/Rustler — safe Rust bridge for creating Erlang NIF functions
- Java
- drrb/java-rust-example — use Rust from Java
- Lua
- jcmoyer/rust-lua53 — Lua 5.3 bindings for Rust
- kballard/rust-lua — Safe Rust bindings to Lua 5.1
- tickbh/td_rlua — Zero-cost high-level lua 5.3 wrapper for Rust
- tomaka/hlua — Rust library to interface with Lua
- mruby
- anima-engine/mrusty — mruby safe bindings for Rust
- Node.js
- rustbridge/neon — use Rust from Node.js
- Objective-C
- SSheldon/rust-objc — Objective-C Runtime bindings and wrapper for Rust
- Python
- dgrunwald/rust-cpython — Python bindings
- lukemetz/rustpy — Python bindings
- R
- rustr/rustr — use Rust from R, and use R in Rust
- Ruby
- rustbridge/helix — write Ruby classes in Rust
IDEs
See also http://areweideyet.com/ and Rust and IDEs.
- intellij-rust — an IntelliJ-based IDE for Rust
- PistonDevelopers/VisualRust — a Visual Studio extension for Rust
- Ride —
- RustDT — an Eclipse-based IDE for Rust
- SolidOak — a simple IDE for Rust, based on GTK+ and Neovim
- Visual Studio Code
Profiling
- ellisonch/rust-stopwatch — a stopwatch library
- FlameGraphs
- mrhooray/torch — generates FlameGraphs based on DWARF Debug Info
- TyOverby/flame —
Testing
[testing]
- BurntSushi/quickcheck [quickcheck] — a Rust implementation of QuickCheck
- farcaller/shiny — a fancy syntax similar to Ruby's Rspec or Objective-C' kiwi
- frewsxcv/afl.rs — a Rust fuzzer, using AFL
- reem/stainless [stainless] — Organized, flexible testing framework
Libraries
Astronomy
- saurvs/astro-rust — astronomy for Rust
- flosse/rust-sun — A rust port of the JS library suncalc
Asynchronous
- zonyitoo/coio-rs — a coroutine I/O library with a working-stealing scheduler
- thehydroimpulse/tangle — a scala-inspired futures library
- dpc/mioco — Scalable, coroutine-based, asynchronous IO handling library
Audio
[audio]
- GuillaumeGomez/rust-fmod — FMOD bindings
- jhasse/ears — a simple library to play Sounds and Musics, on top of OpenAL and libsndfile
- jpernst/openal-rs — OpenAL 1.1 bindings
- musitdev/portmidi-rs — PortMidi bindings
- RustAudio
- RustAudio/rust-portaudio — PortAudio bindings
Authentication
- keats/rust-jwt — JSON Web Token lib in rust
Bioinformatics
- Rust-Bio — bioinformatics libraries in Rust.
Caching
- jaysonsantos/bmemcached-rs — Memcached library written in pure rust
Concurrency
- aturon/crossbeam – Support for parallelism and low-level concurrency in Rust
- nikomatsakis/rayon – A data parallelism library for Rust
- rustcc/coroutine-rs – Coroutine Library in Rust
- zonyitoo/coio-rs – Coroutine I/O for Rust
Cloud
- AWS [aws]
- DigitalOcean
- kbknapp/doapi — DigitalOcean v2 API bindings
Command-line argument parsing
- docopt/docopt.rs — a Rust implementation of DocOpt
- kbknapp/clap-rs — a simple to use, full featured command-line argument parser
Command-line interface
- kkawakam/rustyline — Readline Implementation in Rust
- srijs/rust-copperline — pure-Rust Command Line Editing Library
Compression
- brotli
- ende76/brotli-rs — implementation of Brotli compression
- dropbox/rust-brotli — Brotli decompressor in Rust that optionally avoids the stdlib
- bzip2
- alexcrichton/bzip2-rs — libbz2 bindings
- miniz
- alexcrichton/flate2-rs — miniz bindings
- snappy
- JeffBelgum/rust-snappy — snappy bindings
- tar
- alexcrichton/tar-rs — tar archive reading/writing in Rust
- zip
- slackito/zip — read and write ZIP archives
Computation
- BLAS [blas]
- mikkyang/rust-blas — BLAS bindings
- stainless-steel/blas — BLAS bindings
- GMP
- thestinger/rust-gmp — libgmp bindings
- GSL
- GuillaumeGomez/rust-GSL — GSL bindings
- LAPACK
- stainless-steel/lapack — LAPACK bindings
- Parallel
- arrayfire/arrayfire-rust — Arrayfire bindings
- autumnai/collenchyma — An extensible, pluggable, backend-agnostic framework for parallel, high-performance computations on CUDA, OpenCL and common host CPU.
- luqmana/rust-opencl — OpenCL bindings
- Scirust
- indigits/scirust — scientific computing library in Rust
Cryptography
- briansmith/ring — Safe, fast, small crypto using Rust and BoringSSL's cryptography primitives.
- briansmith/webpki — Web PKI TLS X.509 certificate validation in Rust.
- ctz/rustls - a Rust implementation of TLS
- DaGenix/rust-crypto — cryptographic algorithms in Rust
- dnaq/sodiumoxide — libsodium bindings
- klutzy/suruga — a Rust implementation of TLS 1.2
- libOctavo/octavo — Modular hash and crypto library in Rust
- sfackler/rust-native-tls - Bindings for native TLS libraries
- sfackler/rust-openssl — OpenSSL bindings
- sfackler/rust-security-framework - Bindings for Security Framework (OSX native crypto)
- steffengy/schannel-rs - Bindings for Schannel (Windows native TLS)
Database
[database]
- sfackler/r2d2 — generic connection pool
- NoSQL [nosql]
- Cassandra [cassandra, cql]
- tupshin/cassandra-rust — Cassandra bindings
- CouchDB [couchdb]
- couchdb-rs/couchdb [couchdb] — a Rust client for the CouchDB REST API
- Elasticsearch [elasticsearch]
- benashford/rs-es [rs-es] — a Rust client for the Elastic REST API
- etcd
- jimmycuadra/rust-etcd [etcd] — A client library for CoreOS's etcd.
- ForestDB
- vhbit/sherwood — ForestDB bindings
- LMDB [lmdb]
- vhbit/lmdb-rs [lmdb-rs] — LMDB bindings
- MongoDB [mongodb]
- mongodb-labs/mongo-rust-driver-prototype [mongodb] — MongoDB bindings
- Neo4j [cypher, neo4j]
- Redis [redis]
- mitsuhiko/redis-rs — Redis library in Rust
- UnQLite
- zitsen/unqlite.rs — UnQLite - An Embeddable NoSQL Database Engine library wrapper for Rust
- Cassandra [cassandra, cql]
- SQL [sql]
- Microsoft SQL
- MySql [mysql]
- blackbeam/rust-mysql-simple [mysql] — a native MySql client
- ORM [orm]
- deuterium-orm/deuterium-orm — an SQL query builder for Rust
- diesel-rs/diesel — an ORM and Query builder for Rust
- ivanceras/rustorm — an ORM for Rust
- phonkee/treasure — an ORM for Rust
- PostgreSql [postgres, postgresql]
- sfackler/rust-postgres [postgres] — a native PostgreSQL client
- Sqlite [sqlite]
- dckc/rust-sqlite3 — Sqlite3 bindings
- jgallagher/rusqlite — Sqlite3 bindings
- linuxfood/rustsqlite — Sqlite3 bindings
Data structures
- bluss/rust-itertools —
- contain-rs — Extension of Rust's std::collections
- fizyk20/generic-array – a hack to allow for arrays sized by typenums
- Nemo157/roaring-rs – Roaring Bitmaps in Rust
- reem/rust-typemap —
- serde-rs/serde — a framework to generically serialize Rust data structures
Date and time
Distributed Systems
- Apache Kafka
- Beanstalkd
- schickling/rust-beanstalkd — Beanstalkd bindings
- HDFS
- hyunsik/hdfs-rs — libhdfs bindings
[email]
- gsquire/sendgrid-rs — unofficial Rust library for SendGrid API
- lettre/lettre — an SMTP-library for Rust
Encoding
[encoding]
- ASN.1
- alex/rust-asn1 — a Rust ASN.1 (DER) serializer
- Bencode
- arjantop/rust-bencode — Bencode implementation in Rust
- Binary
- arcnmx/nue — I/O and binary data encoding for Rust
- TyOverby/bincode — a binary encoder/decoder in Rust
- Byte swapping
- BurntSushi/byteorder — Supports big-endian, little-endian and native byte orders
- Cap'n Proto
- CBOR
- BurntSushi/rust-cbor — Supports JSON conversion and type-based encoding/decoding
- Character Encoding
- CRC
- CSV
- HTML
- servo/html5ever — High-performance browser-grade HTML5 parser
- JSON
- serde-rs/json [serde_json] — JSON support for Serde framework
- maciejhirsz/json-rust [json] — JSON implementation in Rust
- Jsonnet
- MsgPack
- mneumann/rust-msgpack —
- 3Hren/msgpack-rust — a pure Rust low/high level MessagePack implementation
- ProtocolBuffers
- RON (Rusty Object Notation)
- Tnetstring
- TOML
- XML
- Florob/RustyXML — an XML parser written in Rust
- shepmaster/sxd-document — An XML library in Rust
- shepmaster/sxd-xpath — An XPath library in Rust
- netvl/xml-rs — a streaming XML library
- YAML
- chyh1990/yaml-rust — The missing YAML 1.2 implementation for Rust.
- dtolnay/serde-yaml [serde_yaml] — YAML support for Serde framework
- kimhyunkang/libyaml-rust — libyaml bindings
Filesystem
- Temporary Files
- rust-lang-nursery/tempdir — temporary directory library
- Stebalien/tempfile — temporary file library
Game development
- Allegro
- SiegeLord/RustAllegro — Allegro 5 bindings
- Amethyst
- ebkalderon/amethyst — data-oriented game engine
- vityafx/challonge-rs [challonge] — Client library for the Challonge REST API. Helps to organize tournaments.
- Corange
- lucidscape/corange-rs — Corange bindings
- Entity-Component Systems (ECS)
- slide-rs/specs — Specs Parallel ECS
- Piston
- Piston —
- SDL [sdl]
- AngryLawyer/rust-sdl2 — SDL2 bindings
- brson/rust-sdl — SDL1 bindings
- SFML
- jeremyletang/rust-sfml — SFML bindings
- Voxlap
- bbodi/rust-voxlap — Voxlap bindings
Geospatial
- Georust — geospatial tools and libraries written in Rust
Graphics
[graphics]
- gfx-rs/gfx — A high-performance, bindless graphics API for Rust.
- OpenGL [opengl]
- brendanzab/gl-rs —
- PistonDevelopers/glfw-rs —
- tomaka/glium — safe OpenGL wrapper for the Rust language.
- tomaka/glutin — Rust alternative to GLFW
- Vulkan [vulkan]
GUI
[gui]
- PistonDevelopers/conrod — An easy-to-use, immediate-mode, 2D GUI library written entirely in Rust
- Cocoa
- IUP
- dcampbell24/iup-rust — IUP bindings
- Kiss-ui — a simple UI framework built on IUP
- GTK+ [gtk]
- gtk-rs/gtk — GTK+ bindings
- libui
- pcwalton/libui-rs — libui bindings
- ncurses [ncurses]
- jeaye/ncurses-rs — ncurses bindings
- saurvs/nfd-rs — Open native UI file dialogs in Linux, OS X and Windows
- Qt
- cyndis/qmlrs — QtQuick bindings
- Sciter
- pravic/rust-sciter — Sciter bindings
- Termbox
- gchp/rustbox — a Rust implementation of Termbox
Image processing
- chyh1990/imageproc — An advanced image processing library for Rust.
- cybergeek94/img-hash — Perceptual image hashing and comparison for equality and similarity.
- PistonDevelopers/image — Basic imaging processing functions and methods for converting to and from image formats
Machine learning
See also About Rust’s Machine Learning Community.
- AtheMathmo/rusty-machine — Machine learning library for Rust
- autumnai/leaf — Open Machine Intelligence framework.
- maciejkula/rustlearn — Machine learning crate for Rust.
Markup language
- CommonMark
- google/pulldown-cmark — CommonMark parser in Rust
Mobile
- Android
- tomaka/android-rs-glue — glue between Rust and Android
- iOS
- TimNN/cargo-lipo — a cargo lipo subcommand which automatically creates a universal library for use with your iOS application.
- vhbit/ObjCrust — using Rust to create an iOS static library
- Pebble
- andars/pebble.rs — a crate that allows Rust to be used to develop Pebble applications.
Network programming
- FTP
- mattnenterprise/rust-ftp — an FTP client for Rust
- Low level
- libpnet/libpnet — a cross-platform, low level networking
- NanoMsg
- thehydroimpulse/nanomsg.rs — nanomsg bindings
- NNTP
- mattnenterprise/rust-nntp — an NNTP client for Rust
- POP3
- mattnenterprise/rust-pop3 — a POP3 client for Rust
- SSH
- alexcrichton/ssh2-rs — libssh2 bindings
- Stomp
- zslayton/stomp-rs — a STOMP 1.2 client implementation in Rust
- uTP
- meqif/rust-utp — a uTP (Micro Transport Protocol) library for Rust.
- ZeroMQ
- erickt/rust-zmq — ZeroMQ bindings
Parser
- dragostis/pest - Elegant, efficient grammars
- Geal/nom — parser combinator library
- ivanceras/inquerest — an URL parameter parser for rest filter inquiry
- kevinmehall/rust-peg — Parsing Expression Grammar (PEG) parser generator
- m4rw3r/chomp – A fast monadic-style parser combinator
- Marwes/combine — parser combinator library
- nikomatsakis/lalrpop — LR(1) parser generator for Rust
- ptal/oak — a typed PEG parser generator (compiler plugin)
- rustless/queryst — a query string parsing library for Rust inspired by https://github.com/ljharb/qs
Platform specific
- Linux
- hannobraun/inotify-rs — inotify bindings
- Unix-like
- nix-rust/nix — Unix-like API bindings
- zargony/rust-fuse — FUSE bindings
- Windows
- retep998/winapi-rs — Windows API bindings
Template engine
- Handlebars
- sunng87/handlebars-rust — Handlebars template engine with inheritance, custom helper support.
- HTML
- lfairy/maud — compile-time HTML templates
- Stebalien/horrorshow-rs — compile-time HTML templates
- Mustache
- tailhook/marafet — Compiler for Jade-like template language to cito.js-based virtual dom
Text processing
- BurntSushi/suffix — Linear time suffix array construction (with Unicode support)
- BurntSushi/tabwriter — Elastic tab stops (i.e., text column alignment)
- pwoolcoc/ngrams — Construct n-grams from arbitrary iterators
- rust-lang-nursery/regex — Regular expressions (RE2 style)
Text rendering
- dylanede/rusttype — A pure Rust alternative to libraries like FreeType.
Virtualization
- beneills/quantum — Advanced Rust quantum computer simulator
- ekse/unicorn-rs — Rust bindings for the unicorn CPU emulator
- saurvs/hypervisor-rs — Hardware-accelerated virtualization on OS X
Web programming
See also Rust web framework comparison.
- HTTP Client
- alexcrichton/curl-rust — libcurl bindings
- hyperium/hyper — an HTTP implementation
- vhbit/curl-rs — libcurl bindings
- HTTP Server
- fengsp/pencil —
- hyperium/hyper — an HTTP implementation
- Iron — a middleware-based server framework
- sunng87/handlebars-iron — Handlebars-rust as an Iron web framework middleware.
- Nickel — inspired by Express
- Ogeon/rustful — a RESTful web framework for Rust
- Rustless — a REST-like API micro-framework inspired by Grape and Hyper
- tiny-http — Low level HTTP server library
- WebSocket
- cyderize/rust-websocket — a framework for dealing with WebSocket connections (both clients and servers)
- vityafx/urlshortener-rs [urlshortener] — A very simple urlshortener library for Rust.
- housleyjk/ws-rs — lightweight, event-driven WebSockets for Rust
Resources
- Benchmarks
- TeXitoi/benchmarksgame-rs — Rust implementations for the The Computer Language Benchmarks Game
- Learning
- exercism.io - programming exercises that help you learn new concepts in Rust.
- Rust by Example
- rust-learning — a collection of useful resources to learn Rust
- Rustlings — small exercises to get you used to reading and writing Rust code
- Podcasts
- New Rustacean — a podcast about learning Rust
- Rusty Radio — covering the rust ecosystem
- RustCamp 2015 Talks
- Rust Design Patterns
- Rust Guidelines
from https://github.com/kud1ing/awesome-rust
-----------
A web frontend for the Rust compiler 。
Be warned: very work in progress!
Contents:
You can play with a live demo. Be warned that it is very, very slow since it is running on a crappy server and rustw is not designed to be run over the internet. When run locally, it is much snappier.
Motivation:
Running
Currently, rustw has only been tested on Firefox on Linux (issue 48).
If you want to play with cool features like 'jump to definition', see the customisation below.
On Linux:
Some features need configuration in the rustw.toml before they can be properly used. Set the following properties to use the cool stuff:
To rebuild, reload the page (quickest way is to hit F5) or click the
You'll see a summary of errors and warnings. You can hide the details (notes, etc.) by clicking the
You can click error codes to see explanations。
-----------
A web frontend for the Rust compiler 。
rustw
A web frontend for the Rust compiler. Displays errors in an easily readable, concise layout, gives easy access to more information, quickly allows reading or editing code.Be warned: very work in progress!
Contents:
You can play with a live demo. Be warned that it is very, very slow since it is running on a crappy server and rustw is not designed to be run over the internet. When run locally, it is much snappier.
Motivation:
- Better errors - we should have interactive experiences for exploring and visualising errors involving the borrow checker, macros, etc. Also, easy access to error explanations and docs.
- Explore code - provide a platform for searching and understanding source code.
- Convenience - one click (or keystroke) to rebuild, easy to edit and explore code, GUI for multirust (in some ways this is a minimal IDE experience, focused on building, rather than editing).
Building
Requires a nightly version of Rust to build.- setup the React/webpack environment (requires npm):
npm install
# if you have yarn installed:
yarn
# if not:
npm install --save react react-dom redux react-redux redux-thunk
npm install --save-dev babel-loader babel-core
npm install --save-dev babel-preset-react
npm install --save-dev babel-preset-es2015
npm install --save-dev babel-plugin-transform-object-rest-spread
npm install --save-dev webpack
npm install --save-dev immutable
- build the JS components:
npm run build
oryarn build
cargo build --release
to build the Rust parts.
Running
rustw
in your project's directory (i.e., the directory you would normally use
cargo or rustc from).Running
rustw
will start a web server and display a URL in the console. To
terminate the server, use ctrl + c
. If you point your browser at the provided
URL, it will build your project, output will be displayed in your browser. The
terminal is only used to display some logging, it can be ignored. See
tour for more.Currently, rustw has only been tested on Firefox on Linux (issue 48).
If you want to play with cool features like 'jump to definition', see the customisation below.
Troubleshooting
If you get an error likeerror while loading shared libraries
while starting
up rustw you should try the following:On Linux:
export LD_LIBRARY_PATH=$(rustc --print sysroot)/lib:$LD_LIBRARY_PATH
On MacOS:export DYLD_LIBRARY_PATH=$(rustc --print sysroot)/lib:$DYLD_LIBRARY_PATH
Customisation
Create arustw.toml
file in your project's directory. See src/config.rs
or run rustw -h
for the options available and their defaults.Some features need configuration in the rustw.toml before they can be properly used. Set the following properties to use the cool stuff:
save_analysis = true
This means rustw will run rustc with -Zsave-analysis
, this gives you access to
analysis information from the compiler which is used in jump to defintion
,
types on hover, refactoring, etc.edit_command = "subl $file:$line"
To be able to open files in your local editor. This example works for sublime
text (subl
). Use the $file
and $line
variables as appropriate for your
editor.vcs_link = "https://github.com/nrc/rustw-test/blob/master/$file#L$line"
For links to the code in version control.Tour
On loading rustw in your browser it builds the project. When the build is complete you'll see the output from stdout (messages, hidden by default) and stderr (errors, warnings, etc., shown by default). If you project compiles without errors or warnings this won't be very interesting!To rebuild, reload the page (quickest way is to hit F5) or click the
rebuild
button.You'll see a summary of errors and warnings. You can hide the details (notes, etc.) by clicking the
-
buttons. You can show code snippets by clicking the
+
buttons next to filenames. This will show syntax highlighted code with the
source of the error (or note, etc.) highlighted. If you click on the filename
itself, it will take you to a source code view of that file. You can right click
these links to bring up a menu, here you have options to edit the file (which
opens the file in an editor which must be specified in rustw.toml
) or make a
'quick edit', which pops up a text box to edit the code in the browser.You can click error codes to see explanations。
from https://github.com/nrc/rustw
-------------
https://project-awesome.org/rust-unofficial/awesome-rust