サクサク読めて、アプリ限定の機能も多数!
トップへ戻る
TGS2024
tokio.rs
Today, we are happy to announce the initial release of tokio-metrics, a crate for getting a Tokio application's runtime and task level metrics. Tokio Metrics makes it easier for Tokio users to debug performance problems with their applications by providing visibility into runtime behaviors in production. Today, Tokio is used successfully in large-scale production deployments at companies like Amaz
Today, we, the Tokio team, are announcing the initial release of Tokio Console (Github), enabling Rust developers to gain deeper insight into the runtime behavior of their applications. And just like that, we get to peek under the hood. —niedzejkob Tokio Console is a diagnostics and debugging tool for asynchronous Rust programs. It gives you a live, easy-to-navigate view into the program's tasks a
Today we are happy to announce axum: An easy to use, yet powerful, web framework designed to take full advantage of the Tokio ecosystem. High level features Route requests to handlers with a macro free API. Declaratively parse requests using extractors. Simple and predictable error handling model. Generate responses with minimal boilerplate. Take full advantage of the tower and tower-http ecosyste
Announcing tokio-uring: io-uring support for TokioJuly 19, 2021 Today, we published the first release of the “tokio-uring” crate, providing support for the io-uring system API on Linux. This release provides asynchronous File operations, and we will be adding support for more operations in subsequent releases. To use tokio-uring, first, add a dependency on the crate: tokio-uring = "0.1.0" Then, st
We are pleased to announce the 1.0 release of Tokio, an asynchronous runtime for the Rust programming language. Tokio provides the needed building blocks for writing reliable networking applications without compromising speed. It comes with asynchronous APIs for TCP, UDP, timers, a multi-threaded, work-stealing scheduler, and more. Over the years, we have been delighted watching our users build am
Tokio is an asynchronous runtime for the Rust programming language. It provides the building blocks needed for writing networking applications. It gives the flexibility to target a wide range of systems, from large servers with dozens of cores to small embedded devices. At a high level, Tokio provides a few major components: A multi-threaded runtime for executing asynchronous code. An asynchronous
Announcing Tokio 0.2 and a Roadmap to 1.0November 26, 2019 We are very excited to announce Tokio 0.2. This is a ground up rework of Tokio based on async / await and experience gained over the past three years. Add the following to Cargo.toml: tokio = { version = "0.2", features = ["full"] } This is a major update, and as such there are changes to almost all parts of the library. To highlight a few
Making the Tokio scheduler 10x fasterOctober 13, 2019 We've been hard at work on the next major revision of Tokio, Rust's asynchronous runtime. Today, a complete rewrite of the scheduler has been submitted as a pull request. The result is huge performance and latency improvements. Some benchmarks saw a 10x speed up! It is always unclear how much these kinds of improvements impact "full stack" use
A great 2018, an even better 2019December 19, 2018 A year ago, Tokio was a very different library. It includes the (now deprecated) tokio-core which provided a future executor, I/O selector, and basic TCP/UDP types in a single library. It also included tokio-proto, but we won't talk about that. Over the past year, Tokio has grown to become Rust's asynchronous I/O platform. It has been adopted by a
Experimental async / await support for TokioAugust 27, 2018 Happy Monday! In case you haven't heard, async / await is a big new feature that is being worked on for Rust. It aims to make asynchronous programming easy (well, at least a little bit easier than it is today). The work has been on going for a while and is already usable today on the Rust nightly channel. I'm happy to announce that Tokio
New Tokio release, now with filesystem supportMay 5, 2018 It took a bit longer than I had initially hoped (as it always does), but a new Tokio version has been released. This release includes, among other features, a new set of APIs that allow performing filesystem operations from an asynchronous context. Filesystem APIs Interacting with files (and other filesystem types) requires* blocking system
I'm happy to announce a new release of Tokio. This release includes the first iteration of the Tokio Runtime. tl;dr This is how a multi-threaded Tokio based server is now written: extern crate tokio; use tokio::net::TcpListener; use tokio::prelude::*; fn process(s: TcpStream) -> impl Future<Item = (), Error = ()> + Send { ... } let addr = "127.0.0.1:8080".parse().unwrap(); let listener = TcpListen
Today we’re happy to announce a new crate and several new tools to work with in the Tokio stack. This represents the culmination of a number of parallel updates to various bits and pieces, they just happened to conveniently land all around the same time! In a nutshell the improvements are: A new tokio-io crate extracted from tokio-core , deprecating the tokio_core::io module. Introduction of the b
Today we are publishing the preliminary version of the Tokio stack, 0.1! Tokio is a platform for writing fast networking code in Rust. It’s built on futures, a zero-cost abstraction for asynchronous programming in Rust . It provides a suite of basic tools, tokio-core , for asynchronous I/O with futures. It also provide a higher-level layer, tokio-proto , for easily building sophisticated servers a
Build reliable network applications without compromising speed.Tokio is an asynchronous runtime for the Rust programming language. It provides the building blocks needed for writing network applications. It gives the flexibility to target a wide range of systems, from large servers with dozens of cores to small embedded devices.
このページを最初にブックマークしてみませんか?
『Tokio - An asynchronous Rust runtime』の新着エントリーを見る
j次のブックマーク
k前のブックマーク
lあとで読む
eコメント一覧を開く
oページを開く