Rust on Producthunt daily

gpui-component

Wed, 29 Oct 2025 15:29:01 +0800

longbridge/gpui-component

GPUI Component

UI components for building fantastic desktop applications using GPUI.

Features

Richness: 60+ cross-platform desktop UI components.
Native: Inspired by macOS and Windows controls, combined with shadcn/ui design for a modern experience.
Ease of Use: Stateless RenderOnce components, simple and user-friendly.
Customizable: Built-in Theme and ThemeColor, supporting multi-theme and variable-based configurations.
Versatile: Supports sizes like xs, sm, md, and lg.
Flexible Layout: Dock layout for panel arrangements, resizing, and freeform (Tiles) layouts.
High Performance: Virtualized Table and List components for smooth large-data rendering.
Content Rendering: Native support for Markdown and simple HTML.
Charting: Built-in charts for visualizing your data.
Editor: High performance code editor (support up to 200K lines) with LSP (diagnostics, completion, hover, etc).
Syntax Highlighting: Syntax highlighting for editor and markdown components using Tree Sitter.

Showcase

Here is the first application: Longbridge Pro, built using GPUI Component.

We built multi-theme support in the application. This feature is not included in GPUI Component itself, but is based on the Theme feature, so it’s easy to implement.

Usage

GPUI and GPUI Component are still in development, so you need to add dependencies by git.

1
2

gpui = "0.2.2"
gpui-component = "0.3.0"

Basic Example

use gpui::*;
use gpui_component::{button::*, *};

pub struct HelloWorld;
impl Render for HelloWorld {
    fn render(&mut self, _: &mut Window, _: &mut Context<Self>) -> impl IntoElement {
        div()
            .v_flex()
            .gap_2()
            .size_full()
            .items_center()
            .justify_center()
            .child("Hello, World!")
            .child(
                Button::new("ok")
                    .primary()
                    .label("Let's Go!")
                    .on_click(|_, _, _| println!("Clicked!")),
            )
    }
}

fn main() {
    let app = Application::new();

    app.run(move |cx| {
        // This must be called before using any GPUI Component features.
        gpui_component::init(cx);

        cx.spawn(async move |cx| {
            cx.open_window(WindowOptions::default(), |window, cx| {
                let view = cx.new(|_| HelloWorld);
                // This first level on the window, should be a Root.
                cx.new(|cx| Root::new(view.into(), window, cx))
            })?;

            Ok::<_, anyhow::Error>(())
        })
        .detach();
    });
}

WebView

Still early and experimental; there are a lot of limitations.

GPUI Component has a WebView element based on Wry. This is an optional feature, which you can enable with a feature flag.

1
2

gpui-component = { version = "0.3.0", features = ["webview"] }
wry = { version = "0.53.3, package = "lb-wry" }

More usage examples can be found in the story directory.

Icons

GPUI Component has an Icon element, but it does not include SVG files by default.

The example uses Lucide icons, but you can use any icons you like. Just name the SVG files as defined in IconName. You can add any icons you need to your project.

Development

We have a gallery of applications built with GPUI Component.

`1`	`cargo run`

More examples can be found in the examples directory. You can run them with cargo run --example <example_name>.

Check out CONTRIBUTING.md for more details.

Compare to others

Features	GPUI Component	Iced	egui	Qt 6
Language	Rust	Rust	Rust	C++/QML
Core Render	GPUI	wgpu	wgpu	QT
License	Apache 2.0	MIT	MIT/Apache 2.0	Commercial/LGPL
Min Binary Size ¹	12MB	11MB	5M	20MB ²
Cross-Platform	Yes	Yes	Yes	Yes
Documentation	Simple	Simple	Simple	Good
Web	No	Yes	Yes	Yes
UI Style	Modern	Basic	Basic	Basic
CJK Support	Yes	Yes	Bad	Yes
Chart	Yes	No	No	Yes
Table (Large dataset)	Yes (Virtual Rows, Columns)	No	Yes (Virtual Rows)	Yes (Virtual Rows, Columns)
Table Column Resize	Yes	No	Yes	Yes
Text base	Rope	COSMIC Text ³	trait TextBuffer ⁴	QTextDocument
CodeEditor	Simple	Simple	Simple	Basic API
Dock Layout	Yes	Yes	Yes	Yes
Syntax Highlight	Tree Sitter	Syntect	Syntect	QSyntaxHighlighter
Markdown Rendering	Yes	Yes	Basic	No
Markdown mix HTML	Yes	No	No	No
HTML Rendering	Basic	No	No	Basic
Text Selection	TextView	No	Any Label	Yes
Custom Theme	Yes	Yes	Yes	Yes
Built Themes	Yes	No	No	No
I18n	Yes	Yes	Yes	Yes

Please submit an issue or PR if any mistakes or outdated are found.

License

Apache-2.0

UI design based on shadcn/ui.
Icons from Lucide.

Release builds by use simple hello world example. ↩︎
Reducing Binary Size of Qt Applications ↩︎
Iced Editor: https://github.com/iced-rs/iced/blob/db5a1f6353b9f8520c4f9633d1cdc90242c2afe1/graphics/src/text/editor.rs#L65-L68 ↩︎
egui TextBuffer: https://github.com/emilk/egui/blob/0a81372cfd3a4deda640acdecbbaf24bf78bb6a2/crates/egui/src/widgets/text_edit/text_buffer.rs#L20 ↩︎

servo

Thu, 23 Oct 2025 15:28:44 +0800

servo/servo

The Servo Parallel Browser Engine Project

Servo is a prototype web browser engine written in the Rust language. It is currently developed on 64-bit macOS, 64-bit Linux, 64-bit Windows, 64-bit OpenHarmony, and Android.

Servo welcomes contribution from everyone. Check out:

The Servo Book for documentation
servo.org for news and guides

Coordination of Servo development happens:

Here in the Github Issues
On the Servo Zulip
In video calls advertised in the Servo Project repo.

Getting started

For more detailed build instructions, see the Servo book under Setting up your environment, Building Servo, Building for Android and Building for OpenHarmony.

macOS

Download and install Xcode and brew.
Install uv: curl -LsSf https://astral.sh/uv/install.sh | sh
Install rustup: curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
Restart your shell to make sure cargo is available
Install the other dependencies: ./mach bootstrap
Build servoshell: ./mach build

Linux

Install curl:
- Arch: sudo pacman -S --needed curl
- Debian, Ubuntu: sudo apt install curl
- Fedora: sudo dnf install curl
- Gentoo: sudo emerge net-misc/curl
Install uv: curl -LsSf https://astral.sh/uv/install.sh | sh
Install rustup: curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
Restart your shell to make sure cargo is available
Install the other dependencies: ./mach bootstrap
Build servoshell: ./mach build

Windows

Download uv, choco, and rustup
- Be sure to select Quick install via the Visual Studio Community installer
In the Visual Studio Installer, ensure the following components are installed:
- Windows 10/11 SDK (anything >= 10.0.19041.0) (Microsoft.VisualStudio.Component.Windows{10, 11}SDK.{>=19041})
- MSVC v143 - VS 2022 C++ x64/x86 build tools (Latest) (Microsoft.VisualStudio.Component.VC.Tools.x86.x64)
- C++ ATL for latest v143 build tools (x86 & x64) (Microsoft.VisualStudio.Component.VC.ATL)
Restart your shell to make sure cargo is available
Install the other dependencies: .\mach bootstrap
Build servoshell: .\mach build

Android

Ensure that the following environment variables are set:
- ANDROID_SDK_ROOT
- ANDROID_NDK_ROOT: $ANDROID_SDK_ROOT/ndk/28.2.13676358/ ANDROID_SDK_ROOT can be any directory (such as ~/android-sdk). All of the Android build dependencies will be installed there.
Install the latest version of the Android command-line tools to $ANDROID_SDK_ROOT/cmdline-tools/latest.

Run the following command to install the necessary components:

sudo $ANDROID_SDK_ROOT/cmdline-tools/latest/bin/sdkmanager --install \
 "build-tools;34.0.0" \
 "emulator" \
 "ndk;28.2.13676358" \
 "platform-tools" \
 "platforms;android-33" \
 "system-images;android-33;google_apis;x86_64"

Follow the instructions above for the platform you are building on

OpenHarmony

Follow the instructions above for the platform you are building on to prepare the environment.
Depending on the target distribution (e.g. HarmonyOS NEXT vs pure OpenHarmony) the build configuration will differ slightly.
Ensure that the following environment variables are set
- DEVECO_SDK_HOME (Required when targeting HarmonyOS NEXT)
- OHOS_BASE_SDK_HOME (Required when targeting OpenHarmony)
- OHOS_SDK_NATIVE (e.g. ${DEVECO_SDK_HOME}/default/openharmony/native or ${OHOS_BASE_SDK_HOME}/${API_VERSION}/native)
- SERVO_OHOS_SIGNING_CONFIG: Path to json file containing a valid signing configuration for the demo app.
Review the detailed instructions at Building for OpenHarmony.
The target distribution can be modified by passing --flavor=<default|harmonyos> to mach <build|package|install>.

solana

Thu, 25 Sep 2025 15:29:48 +0800

solana-labs/solana

PLEASE READ: This repo is now a public archive

This repo still exists in archived form, feel free to fork any reference implementations it still contains.

See Agave, the Solana validator implementation from Anza: https://github.com/anza-xyz/agave

Building

1. Install rustc, cargo and rustfmt.

1
2
3

$ curl https://sh.rustup.rs -sSf | sh
$ source $HOME/.cargo/env
$ rustup component add rustfmt

When building the master branch, please make sure you are using the latest stable rust version by running:

`1`	`$ rustup update`

When building a specific release branch, you should check the rust version in ci/rust-version.sh and if necessary, install that version by running:

`1`	`$ rustup install VERSION`

Note that if this is not the latest rust version on your machine, cargo commands may require an override in order to use the correct version.

On Linux systems you may need to install libssl-dev, pkg-config, zlib1g-dev, protobuf etc.

On Ubuntu:

1
2

$ sudo apt-get update
$ sudo apt-get install libssl-dev libudev-dev pkg-config zlib1g-dev llvm clang cmake make libprotobuf-dev protobuf-compiler

On Fedora:

`1`	`$ sudo dnf install openssl-devel systemd-devel pkg-config zlib-devel llvm clang cmake make protobuf-devel protobuf-compiler perl-core`

2. Download the source code.

1
2

$ git clone https://github.com/solana-labs/solana.git
$ cd solana

3. Build.

`1`	`$ ./cargo build`

Testing

Run the test suite:

`1`	`$ ./cargo test`

Starting a local testnet

Start your own testnet locally, instructions are in the online docs.

Accessing the remote development cluster

devnet - stable public cluster for development accessible via devnet.solana.com. Runs 24/7. Learn more about the public clusters

Benchmarking

First, install the nightly build of rustc. cargo bench requires the use of the unstable features only available in the nightly build.

`1`	`$ rustup install nightly`

Run the benchmarks:

`1`	`$ cargo +nightly bench`

Release Process

The release process for this project is described here.

Code coverage

To generate code coverage statistics:

1
2

$ scripts/coverage.sh
$ open target/cov/lcov-local/index.html

Why coverage? While most see coverage as a code quality metric, we see it primarily as a developer productivity metric. When a developer makes a change to the codebase, presumably it’s a solution to some problem. Our unit-test suite is how we encode the set of problems the codebase solves. Running the test suite should indicate that your change didn’t infringe on anyone else’s solutions. Adding a test protects your solution from future changes. Say you don’t understand why a line of code exists, try deleting it and running the unit-tests. The nearest test failure should tell you what problem was solved by that code. If no test fails, go ahead and submit a Pull Request that asks, “what problem is solved by this code?” On the other hand, if a test does fail and you can think of a better way to solve the same problem, a Pull Request with your solution would most certainly be welcome! Likewise, if rewriting a test can better communicate what code it’s protecting, please send us that patch!

Disclaimer

All claims, content, designs, algorithms, estimates, roadmaps, specifications, and performance measurements described in this project are done with the Solana Labs, Inc. (“SL”) good faith efforts. It is up to the reader to check and validate their accuracy and truthfulness. Furthermore, nothing in this project constitutes a solicitation for investment.

Any content produced by SL or developer resources that SL provides are for educational and inspirational purposes only. SL does not encourage, induce or sanction the deployment, integration or use of any such applications (including the code comprising the Solana blockchain protocol) in violation of applicable laws or regulations and hereby prohibits any such deployment, integration or use. This includes the use of any such applications by the reader (a) in violation of export control or sanctions laws of the United States or any other applicable jurisdiction, (b) if the reader is located in or ordinarily resident in a country or territory subject to comprehensive sanctions administered by the U.S. Office of Foreign Assets Control (OFAC), or (c) if the reader is or is working on behalf of a Specially Designated National (SDN) or a person subject to similar blocking or denied party prohibitions.

The reader should be aware that U.S. export control and sanctions laws prohibit U.S. persons (and other persons that are subject to such laws) from transacting with persons in certain countries and territories or that are on the SDN list. Accordingly, there is a risk to individuals that other persons using any of the code contained in this repo, or a derivation thereof, may be sanctioned persons and that transactions with such persons would be a violation of U.S. export controls and sanctions law.

bevy

Tue, 23 Sep 2025 15:28:09 +0800

bevyengine/bevy

What is Bevy?

Bevy is a refreshingly simple data-driven game engine built in Rust. It is free and open-source forever!

WARNING

Bevy is still in the early stages of development. Important features are missing. Documentation is sparse. A new version of Bevy containing breaking changes to the API is released approximately once every 3 months. We provide migration guides, but we can’t guarantee migrations will always be easy. Use only if you are willing to work in this environment.

MSRV: Bevy relies heavily on improvements in the Rust language and compiler. As a result, the Minimum Supported Rust Version (MSRV) is generally close to “the latest stable release” of Rust.

Design Goals

Capable: Offer a complete 2D and 3D feature set
Simple: Easy for newbies to pick up, but infinitely flexible for power users
Data Focused: Data-oriented architecture using the Entity Component System paradigm
Modular: Use only what you need. Replace what you don’t like
Fast: App logic should run quickly, and when possible, in parallel
Productive: Changes should compile quickly … waiting isn’t fun

About

Features: A quick overview of Bevy’s features.
News: A development blog that covers our progress, plans and shiny new features.

Docs

Quick Start Guide: Bevy’s official Quick Start Guide. The best place to start learning Bevy.
Bevy Rust API Docs: Bevy’s Rust API docs, which are automatically generated from the doc comments in this repo.
Official Examples: Bevy’s dedicated, runnable examples, which are great for digging into specific concepts.
Community-Made Learning Resources: More tutorials, documentation, and examples made by the Bevy community.

Community

Before contributing or participating in discussions with the community, you should familiarize yourself with our Code of Conduct.

Discord: Bevy’s official discord server.
Reddit: Bevy’s official subreddit.
GitHub Discussions: The best place for questions about Bevy, answered right here!
Bevy Assets: A collection of awesome Bevy projects, tools, plugins and learning materials.

Contributing

If you’d like to help build Bevy, check out the Contributor’s Guide. For simple problems, feel free to open an issue or PR and tackle it yourself!

For more complex architecture decisions and experimental mad science, please open an RFC (Request For Comments) so we can brainstorm together effectively!

Getting Started

We recommend checking out the Quick Start Guide for a brief introduction.

Follow the Setup guide to ensure your development environment is set up correctly. Once set up, you can quickly try out the examples by cloning this repo and running the following commands:

# Switch to the correct version (latest release, default is main development branch)
git checkout latest
# Runs the "breakout" example
cargo run --example breakout

To draw a window with standard functionality enabled, use:

use bevy::prelude::*;

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .run();
}

Fast Compiles

Bevy can be built just fine using default configuration on stable Rust. However for really fast iterative compiles, you should enable the “fast compiles” setup by following the instructions here.

Bevy Cargo Features

This list outlines the different cargo features supported by Bevy. These allow you to customize the Bevy feature set for your use-case.

Thanks

Bevy is the result of the hard work of many people. A huge thanks to all Bevy contributors, the many open source projects that have come before us, the Rust gamedev ecosystem, and the many libraries we build on.

A huge thanks to Bevy’s generous sponsors. Bevy will always be free and open source, but it isn’t free to make. Please consider sponsoring our work if you like what we’re building.

This project is tested with BrowserStack.

License

Bevy is free, open source and permissively licensed! Except where noted (below and/or in individual files), all code in this repository is dual-licensed under either:

MIT License (LICENSE-MIT or http://opensource.org/licenses/MIT)
Apache License, Version 2.0 (LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0)

at your option. This means you can select the license you prefer! This dual-licensing approach is the de-facto standard in the Rust ecosystem and there are very good reasons to include both.

Some of the engine’s code carries additional copyright notices and license terms due to their external origins. These are generally BSD-like, but exact details vary by crate: If the README of a crate contains a ‘License’ header (or similar), the additional copyright notices and license terms applicable to that crate will be listed. The above licensing requirement still applies to contributions to those crates, and sections of those crates will carry those license terms. The license field of each crate will also reflect this.

The assets included in this repository (for our examples) typically fall under different open licenses. These will not be included in your game (unless copied in by you), and they are not distributed in the published bevy crates. See CREDITS.md for the details of the licenses of those files.

Your contributions

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.

linera-protocol

Sun, 21 Sep 2025 15:24:17 +0800

linera-io/linera-protocol

Linera is a decentralized blockchain infrastructure designed for highly scalable, secure, low-latency Web3 applications.

Documentation

Visit our developer page and read our whitepaper to learn more about the Linera protocol.

Repository Structure

The main crates and directories of this repository can be summarized as follows: (listed from low to high levels in the dependency graph)

linera-base Base definitions, including cryptography.
linera-version A library to manage version info in binaries and services.
linera-views A library mapping complex data structures onto a key-value store. The corresponding procedural macros are implemented in linera-views-derive.
linera-execution Persistent data and the corresponding logic for runtime and execution of Linera applications.
linera-chain Persistent data and the corresponding logic for chains of blocks, certificates, and cross-chain messaging.
linera-storage Defines the storage abstractions for the protocol on top of linera-chain.
linera-core The core Linera protocol, including client and server logic, node synchronization, etc.
linera-rpc Defines the data-type for RPC messages (currently all client ↔ proxy ↔ chain ↔ chain interactions), and track the corresponding data schemas.
linera-client Library for writing Linera clients. Used for the command-line client and the node service in linera-service, as well as the Web client in linera-web.
linera-service Executable for clients (aka CLI wallets), proxy (aka validator frontend) and servers.
linera-sdk The library to develop Linera applications written in Rust for the Wasm virtual machine. The corresponding procedural macros are implemented in linera-sdk-derive.
examples Examples of Linera applications written in Rust.

Prerequisites

See INSTALL.md for software requirements to develop in this repo.

Quickstart with the Linera CLI tool

The following commands set up a local test network and run some transfers between the microchains owned by a single wallet.

# Make sure to compile the Linera binaries and add them in the $PATH.
# cargo build -p linera-storage-service -p linera-service --bins
export PATH="$PWD/target/debug:$PATH"

# Import the optional helper function `linera_spawn`.
source /dev/stdin <<<"$(linera net helper 2>/dev/null)"

# Run a local test network with the default parameters and a number of microchains
# owned by the default wallet. This also defines `LINERA_TMP_DIR`.
linera_spawn \
linera net up --with-faucet --faucet-port 8080

# Remember the URL of the faucet.
FAUCET_URL=http://localhost:8080

# If you're using a testnet, start here and run this instead:
#   LINERA_TMP_DIR=$(mktemp -d)
#   FAUCET_URL=https://faucet.testnet-XXX.linera.net  # for some value XXX

# Set the path of the future wallet.
export LINERA_WALLET="$LINERA_TMP_DIR/wallet.json"
export LINERA_KEYSTORE="$LINERA_TMP_DIR/keystore.json"
export LINERA_STORAGE="rocksdb:$LINERA_TMP_DIR/client.db"

# Initialize a new user wallet.
linera wallet init --faucet $FAUCET_URL

# Request chains.
INFO1=($(linera wallet request-chain --faucet $FAUCET_URL))
INFO2=($(linera wallet request-chain --faucet $FAUCET_URL))
CHAIN1="${INFO1[0]}"
ACCOUNT1="${INFO1[1]}"
CHAIN2="${INFO2[0]}"
ACCOUNT2="${INFO2[1]}"

# Show the different chains tracked by the wallet.
linera wallet show

# Query the chain balance of some of the chains.
linera query-balance "$CHAIN1"
linera query-balance "$CHAIN2"

# Transfer 10 units then 5 back.
linera transfer 10 --from "$CHAIN1" --to "$CHAIN2"
linera transfer 5 --from "$CHAIN2" --to "$CHAIN1"

# Query balances again.
linera query-balance "$CHAIN1"
linera query-balance "$CHAIN2"

# Now let's fund the user balances.
linera transfer 5 --from "$CHAIN1" --to "$CHAIN1:$ACCOUNT1"
linera transfer 2 --from "$CHAIN1:$ACCOUNT1" --to "$CHAIN2:$ACCOUNT2"

# Query user balances again.
linera query-balance "$CHAIN1:$ACCOUNT1"
linera query-balance "$CHAIN2:$ACCOUNT2"

More complex examples may be found in our developer manual as well as the example applications in this repository.

Contributing

We welcome contributions from the community! If you’d like to contribute to the Linera protocol:

Fork the repository
Create a feature branch (git checkout -b feature/amazing-feature)
Commit your changes (git commit -m 'Add some amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Open a Pull Request

For detailed guidelines, see our contribution guide.

coreutils

Tue, 09 Sep 2025 15:29:32 +0800

uutils/coreutils

uutils coreutils

uutils coreutils is a cross-platform reimplementation of the GNU coreutils in Rust. While all programs have been implemented, some options might be missing or different behavior might be experienced.

To install it:

1
2

cargo install coreutils
~/.cargo/bin/coreutils

Goals

uutils coreutils aims to be a drop-in replacement for the GNU utils. Differences with GNU are treated as bugs.

Our key objectives include:

Matching GNU’s output (stdout and error code) exactly
Better error messages
Providing comprehensive internationalization support (UTF-8)
Improved performances
Extensions when relevant (example: –progress)

uutils aims to work on as many platforms as possible, to be able to use the same utils on Linux, macOS, Windows and other platforms. This ensures, for example, that scripts can be easily transferred between platforms.

Documentation

uutils has both user and developer documentation available:

Both can also be generated locally, the instructions for that can be found in the coreutils docs repository.

Use weblate/rust-coreutils to translate the Rust coreutils into your language.

Requirements

Rust (cargo, rustc)
GNU Make (optional)

Rust Version

uutils follows Rust’s release channels and is tested against stable, beta and nightly. The current Minimum Supported Rust Version (MSRV) is 1.85.0.

Building

There are currently two methods to build the uutils binaries: either Cargo or GNU Make.

Building the full package, including all documentation, requires both Cargo and GNU Make on a Unix platform.

For either method, we first need to fetch the repository:

1
2

git clone https://github.com/uutils/coreutils
cd coreutils

Cargo

Building uutils using Cargo is easy because the process is the same as for every other Rust program:

`1`	`cargo build --release`

This command builds the most portable common core set of uutils into a multicall (BusyBox-type) binary, named ‘coreutils’, on most Rust-supported platforms.

Additional platform-specific uutils are often available. Building these expanded sets of uutils for a platform (on that platform) is as simple as specifying it as a feature:

cargo build --release --features macos
# or ...
cargo build --release --features windows
# or ...
cargo build --release --features unix

If you don’t want to build every utility available on your platform into the final binary, you can also specify which ones you want to build manually. For example:

`1`	`cargo build --features "base32 cat echo rm" --no-default-features`

If you don’t want to build the multicall binary and would prefer to build the utilities as individual binaries, that is also possible. Each utility is contained in its own package within the main repository, named “uu_UTILNAME”. To build individual utilities, use cargo to build just the specific packages (using the --package [aka -p] option). For example:

`1`	`cargo build -p uu_base32 -p uu_cat -p uu_echo -p uu_rm`

GNU Make

Building using make is a simple process as well.

To simply build all available utilities:

make

In release mode:

`1`	`make PROFILE=release`

To build all but a few of the available utilities:

`1`	`make SKIP_UTILS='UTILITY_1 UTILITY_2'`

To build only a few of the available utilities:

`1`	`make UTILS='UTILITY_1 UTILITY_2'`

Installation

Install with Cargo

Likewise, installing can simply be done using:

`1`	`cargo install --path . --locked`

This command will install uutils into Cargo’s bin folder (e.g. $HOME/.cargo/bin).

This does not install files necessary for shell completion or manpages. For manpages or shell completion to work, use GNU Make or see Manually install shell completions/Manually install manpages.

Install with GNU Make

To install all available utilities:

`1`	`make install`

To install using sudo switch -E must be used:

`1`	`sudo -E make install`

To install all but a few of the available utilities:

`1`	`make SKIP_UTILS='UTILITY_1 UTILITY_2' install`

To install only a few of the available utilities:

`1`	`make UTILS='UTILITY_1 UTILITY_2' install`

To install every program with a prefix (e.g. uu-echo uu-cat):

`1`	`make PROG_PREFIX=PREFIX_GOES_HERE install`

To install the multicall binary:

`1`	`make MULTICALL=y install`

Set install parent directory (default value is /usr/local):

1
2

# DESTDIR is also supported
make PREFIX=/my/path install

Installing with make installs shell completions for all installed utilities for bash, fish and zsh. Completions for elvish and powershell can also be generated; See Manually install shell completions.

To skip installation of completions and manpages:

`1`	`make COMPLETIONS=n MANPAGES=n install`

Manually install shell completions

The coreutils binary can generate completions for the bash, elvish, fish, powershell and zsh shells. It prints the result to stdout.

The syntax is:

`1`	`cargo run completion <utility> <shell>`

So, to install completions for ls on bash to /usr/local/share/bash-completion/completions/ls, run:

`1`	`cargo run completion ls bash > /usr/local/share/bash-completion/completions/ls`

Manually install manpages

To generate manpages, the syntax is:

`1`	`cargo run manpage <utility>`

So, to install the manpage for ls to /usr/local/share/man/man1/ls.1 run:

`1`	`cargo run manpage ls > /usr/local/share/man/man1/ls.1`

Un-installation

Un-installation differs depending on how you have installed uutils. If you used Cargo to install, use Cargo to uninstall. If you used GNU Make to install, use Make to uninstall.

Uninstall with Cargo

To uninstall uutils:

`1`	`cargo uninstall coreutils`

Uninstall with GNU Make

To uninstall all utilities:

`1`	`make uninstall`

To uninstall every program with a set prefix:

`1`	`make PROG_PREFIX=PREFIX_GOES_HERE uninstall`

To uninstall the multicall binary:

`1`	`make MULTICALL=y uninstall`

To uninstall from a custom parent directory:

1
2

# DESTDIR is also supported
make PREFIX=/my/path uninstall

GNU test suite compatibility

Below is the evolution of how many GNU tests uutils passes. A more detailed breakdown of the GNU test results of the main branch can be found in the user manual.

See https://github.com/orgs/uutils/projects/1 for the main meta bugs (many are missing).

Contributing

To contribute to uutils, please see CONTRIBUTING.

License

uutils is licensed under the MIT License - see the LICENSE file for details

GNU Coreutils is licensed under the GPL 3.0 or later.

comprehensive-rust

Wed, 03 Sep 2025 15:27:52 +0800

google/comprehensive-rust

Comprehensive Rust 🦀

This repository has the source code for Comprehensive Rust 🦀, a multi-day Rust course developed by the Android team. The course covers all aspects of Rust, from basic syntax to generics and error handling. It also includes deep dives on Android, Chromium, bare-metal, and concurrency.

Read the course at https://google.github.io/comprehensive-rust/.

Course Format and Target Audience

The course is used internally at Google when teaching Rust to experienced software engineers. They typically have a background in C++ or Java.

The course is taught in a classroom setting and we hope it will be useful for others who want to teach Rust to their team. The course will be less useful for self-study since you miss out on the discussions happening in the classroom. You don’t see the questions and answers and you don’t see the compiler errors we trigger when going through the code samples. We hope to improve on this via speaker notes and by publishing videos.

Press

Articles and blog posts from around the web which cover Comprehensive Rust:

2023-09-08: Teaching Rust in 5 days. Comprehensive Rust was used as a base for a 5-day university class on Rust.
2023-09-21: Scaling Rust Adoption Through Training. We published a blog post with details on the development of the course.
2023-10-02: In Search of Rust Developers, Companies Turn to In-House Training. About how Microsoft, Google, and others are training people in Rust.
2024-10-18: Rust Training at Scale | Rust Global @ RustConf 2024. What Google learnt from teaching Comprehensive Rust for more than two years.

Setup

The course is built using a few tools:

First install Rust by following the instructions on https://rustup.rs/. Then clone this repository:

1
2

git clone https://github.com/google/comprehensive-rust/
cd comprehensive-rust

Then install these tools with:

`1`	`cargo xtask install-tools`

Note We use xtask for task automation within the project (e.g. installing required tools). Xtask is not a package that you should install. Visit https://github.com/matklad/cargo-xtask for more information.

Commands

Here are some of the commonly used commands you can run in the project. Run cargo xtask to view all available commands.

Command	Description
`cargo xtask install-tools`	Install all the tools the project depends on.
`cargo xtask serve`	Start a web server with the course. You’ll find the content on http://localhost:3000. To serve any of the translated versions of the course, add the language flag (–language or -l) followed by xx, where xx is the ISO 639 language code (e.g. cargo xtask serve -l da for the Danish translation).
`cargo xtask rust-tests`	Test the included Rust snippets.
`cargo xtask web-tests`	Run the web driver tests in the tests directory.
`cargo xtask build`	Create a static version of the course in the `book/` directory. Note that you have to separately build and zip exercises and add them to book/html. To build any of the translated versions of the course, add the language flag (–language or -l) followed by xx, where xx is the ISO 639 language code (e.g. cargo xtask build -l da for the Danish translation). TRANSLATIONS.md contains further instructions.

Note On Windows, you need to enable symlinks (git config --global core.symlinks true) and Developer Mode.

Contributing

We would like to receive your contributions. Please see CONTRIBUTING.md for details.

Contact

For questions or comments, please contact Martin Geisler or start a discussion on GitHub. We would love to hear from you.

Pake

Wed, 27 Aug 2025 15:28:19 +0800

tw93/Pake

English | 简体中文 | 日本語

Pake

Turn any webpage into a desktop app with Rust with ease.

Pake supports Mac, Windows, and Linux. Check out README for Popular Packages, Command-Line Packaging, and Customized Development information. Feel free to share your suggestions in Discussions.

Features

🎐 Nearly 20 times smaller than an Electron package (around 5M!)
🚀 With Rust Tauri, Pake is much more lightweight and faster than JS-based frameworks.
📦 Battery-included package — shortcut pass-through, immersive windows, and minimalist customization.
👻 Pake is just a simple tool — replace the old bundle approach with Tauri (though PWA is good enough).

Popular Packages

WeRead Mac Windows Linux	Twitter Mac Windows Linux

Grok Mac Windows Linux	DeepSeek Mac Windows Linux

ChatGPT Mac Windows Linux	Gemini Mac Windows Linux

YouTube Music Mac Windows Linux	YouTube Mac Windows Linux

LiZhi Mac Windows Linux	ProgramMusic Mac Windows Linux

Excalidraw Mac Windows Linux	XiaoHongShu Mac Windows Linux

🏂 You can download more applications from Releases. Click here to expand the shortcuts reference!

Mac	Windows/Linux	Function
`⌘` + `[`	`Ctrl` + `←`	Return to the previous page
`⌘` + `]`	`Ctrl` + `→`	Go to the next page
`⌘` + `↑`	`Ctrl` + `↑`	Auto scroll to top of page
`⌘` + `↓`	`Ctrl` + `↓`	Auto scroll to bottom of page
`⌘` + `r`	`Ctrl` + `r`	Refresh Page
`⌘` + `w`	`Ctrl` + `w`	Hide window, not quite
`⌘` + `-`	`Ctrl` + `-`	Zoom out the page
`⌘` + `+`	`Ctrl` + `+`	Zoom in the page
`⌘` + `=`	`Ctrl` + `=`	Zoom in the Page
`⌘` + `0`	`Ctrl` + `0`	Reset the page zoom

In addition, double-click the title bar to switch to full-screen mode. For Mac users, you can also use the gesture to go to the previous or next page and drag the title bar to move the window.

Before starting

For beginners: Play with Popular Packages to find out Pake’s capabilities, or try to pack your application with GitHub Actions. Don’t hesitate to reach for assistance at Discussion!
For developers: “Command-Line Packaging” supports macOS fully. For Windows/Linux users, it requires some tinkering. Configure your environment before getting started.
For hackers: For people who are good at both front-end development and Rust, how about customizing your apps’ function more with the following Customized Development?

Command-Line Packaging

Pake provides a command line tool, making the flow of package customization quicker and easier. See documentation for more information.

# Install with npm
npm install -g pake-cli

# Command usage
pake url [OPTIONS]...

# Feel free to play with Pake! It might take a while to prepare the environment the first time you launch Pake.
pake https://weekly.tw93.fun --name Weekly --hide-title-bar

If you are new to the command line, you can compile packages online with GitHub Actions. See the Tutorial for more information.

Development

Prepare your environment before starting. Make sure you have Rust >=1.89 and Node >=22 (e.g., 22.11.0) installed on your computer. Note: Older versions (Rust ≥1.78, Node ≥16) may also work but latest stable versions are recommended. For installation guidance, see Tauri documentation.

If you are unfamiliar with these, it is better to try out the above tool to pack with one click.

# Install Dependencies
npm i

# Local development [Right-click to open debug mode.]
npm run dev

# Pack application
npm run build

Advanced Usage

You can refer to the codebase structure before working on Pake, which will help you much in development.
Modify the url and productName fields in the pake.json file under the src-tauri directory, the “domain” field in the tauri.config.json file needs to be modified synchronously, as well as the icon and identifier fields in the tauri.xxx.conf.json file. You can select an icon from the icons directory or download one from macOSicons to match your product needs.
For configurations on window properties, you can modify the pake.json file to change the value of width, height, fullscreen (or not), resizable (or not), hide_on_close (hide window on close instead of exiting) of the windows property. To adapt to the immersive header on Mac, change hideTitleBar to true, look for the Header element, and add the padding-top property.
For advanced usages such as style rewriting, advertisement removal, JS injection, container message communication, and user-defined shortcut keys, see Advanced Usage of Pake.

Developers

Pake’s development can not be without these Hackers. They contributed a lot of capabilities for Pake. Also, welcome to follow them! ❤️

_Tw93	_Tlntin	_Santree	_Pan93412	_{Данил Бизимов}	_Volare	_{Bryan Lee}
_Essesoul	_{Jerry Zhou}	_Aiello	_Horus	_{Pake Actions}	_GoodbyeNJN	_Kittizz
_{Matt Bajorek}	_{Srinivas Vaddi}	_Steam	_Qitianjia	_{Yi Xin}	_{Yue Yang}	_Kieran
_孟世博	_2nthony	_Null	_{Abu Taher Siddik}	_{An Li}	_{Ayaka Neko}	_{Dengju Deng}
_Fabien	_Fechin	_Imgbot	_{Jiaqi Gu}	_Milo	_{Po Chen}	_{Xie Ruiqi}
_Null	_Null	_Hyzhao	_Null	_Liudonghua	_Liusishan	_Ranger
_贺天卓

Frequently Asked Questions

Right-clicking on an image element in the page to open the menu and select download image or other events does not work (common in MacOS systems). This issue is due to the MacOS built-in webview not supporting this feature.

Support

I have two cats, TangYuan and Coke. If you think Pake delights your life, you can feed them some canned food 🥩.
If you like Pake, you can star it on GitHub. Also, welcome to recommend Pake to your friends.
You can follow my Twitter to get the latest news of Pake or join our Telegram chat group.
I hope that you enjoy playing with it. Let us know if you find a website that would be great for a Mac App!

trippy

Wed, 23 Jul 2025 15:35:45 +0800

fujiapple852/trippy

Trippy combines the functionality of traceroute and ping and is designed to assist with the analysis of networking issues.

Quick Start

See the getting started guide.

Install

Trippy runs on Linux, BSD, macOS, and Windows. It can be installed from most package managers, precompiled binaries, or source.

For example, to install Trippy from cargo:

`1`	`cargo install trippy --locked`

All package managers

Cargo

`1`	`cargo install trippy --locked`

APT (Debian)

`1`	`apt install trippy`

ⓘ Note:

Only available for Debian 13 (trixie) and later.

PPA (Ubuntu)

1
2

add-apt-repository ppa:fujiapple/trippy
apt update && apt install trippy

ⓘ Note:

Only available for Ubuntu 24.04 (Noble) and 22.04 (Jammy).

Snap (Linux)

`1`	`snap install trippy`

Homebrew (macOS)

`1`	`brew install trippy`

WinGet (Windows)

`1`	`winget install trippy`

Scoop (Windows)

`1`	`scoop install trippy`

Chocolatey (Windows)

`1`	`choco install trippy`

NetBSD

`1`	`pkgin install trippy`

FreeBSD

`1`	`pkg install trippy`

OpenBSD

`1`	`pkg_add trippy`

Arch Linux

`1`	`pacman -S trippy`

Gentoo Linux

`1`	`emerge -av net-analyzer/trippy`

Void Linux

`1`	`xbps-install -S trippy`

ALT Sisyphus

`1`	`apt-get install trippy`

Chimera Linux

`1`	`apk add trippy`

Nix

`1`	`nix-env -iA trippy`

Docker

`1`	`docker run -it fujiapple/trippy`

All Repositories

See the installation guide for details of how to install Trippy on your system.

Run

To run a basic trace to example.com with default settings, use the following command:

`1`	`sudo trip example.com`

See the usage examples and CLI reference for details of how to use Trippy. To use Trippy without elevated privileges, see the privileges guide.

Documentation

Full documentation is available at trippy.rs.

documentation links

Getting Started

See the Getting Started guide.

Features

See the Features list.

Distributions

See the Distributions list.

Privileges

See the Privileges guide.

Usage Examples

See the Usage Examples.

Command Reference

See the Command Reference.

Theme Reference

See the Theme Reference.

Column Reference

See the Column Reference.

Configuration Reference

See the Configuration Reference.

Locale Reference

See the Locale Reference.

Versions

See the Version Reference.

Frequently Asked Questions

Why does Trippy show “Awaiting data…”?

See the Awaiting Data guide.

How do I allow incoming ICMP traffic in the Windows Defender firewall?

See the Windows Defender Firewall guide.

What are the recommended settings for Trippy?

See the Recommended Tracing Settings guide.

Acknowledgements

Trippy is made possible by ratatui ( formerly tui-rs), crossterm as well as several foundational Rust libraries.

Trippy draws heavily from mtr and also incorporates ideas from both libparistraceroute & Dublin Traceroute.

The Trippy networking code is inspired by pnet and some elements of that codebase are incorporated in Trippy.

The AS data is retrieved from the IP to ASN Mapping Service provided by Team Cymru.

The trippy.cli.rs CNAME hosting is provided by cli.rs.

The Trippy chat room is sponsored by Zulip.

Trippy logo designed by Harun Ocaksiz Design.

License

This project is distributed under the terms of the Apache License (Version 2.0).

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in time by you, as defined in the Apache-2.0 license, shall be licensed as above, without any additional terms or conditions.

See LICENSE for details.

edit

Fri, 27 Jun 2025 15:29:25 +0800

microsoft/edit

Edit

A simple editor for simple needs.

This editor pays homage to the classic MS-DOS Editor, but with a modern interface and input controls similar to VS Code. The goal is to provide an accessible editor that even users largely unfamiliar with terminals can easily use.

Installation

You can also download binaries from our Releases page.

Windows

You can install the latest version with WinGet:

`1`	`winget install Microsoft.Edit`

Build Instructions

Install Rust
Install the nightly toolchain: rustup install nightly
- Alternatively, set the environment variable RUSTC_BOOTSTRAP=1
Clone the repository
For a release build, run: cargo build --config .cargo/release.toml --release

Notes to Package Maintainers

Package Naming

The canonical executable name is “edit” and the alternative name is “msedit”. We’re aware of the potential conflict of “edit” with existing commands and recommend alternatively naming packages and executables “msedit”. Names such as “ms-edit” should be avoided. Assigning an “edit” alias is recommended, if possible.

ICU library name (SONAME)

This project optionally depends on the ICU library for its Search and Replace functionality. By default, the project will look for a SONAME without version suffix:

Windows: icuuc.dll
macOS: libicuuc.dylib
UNIX, and other OS: libicuuc.so

If your installation uses a different SONAME, please set the following environment variable at build time:

EDIT_CFG_ICUUC_SONAME: For instance, libicuuc.so.76.
EDIT_CFG_ICUI18N_SONAME: For instance, libicui18n.so.76.

Additionally, this project assumes that the ICU exports are exported without _ prefix and without version suffix, such as u_errorName. If your installation uses versioned exports, please set:

EDIT_CFG_ICU_CPP_EXPORTS: If set to true, it’ll look for C++ symbols such as _u_errorName. Enabled by default on macOS.
EDIT_CFG_ICU_RENAMING_VERSION: If set to a version number, such as 76, it’ll look for symbols such as u_errorName_76.

Finally, you can set the following environment variables:

EDIT_CFG_ICU_RENAMING_AUTO_DETECT: If set to true, the executable will try to detect the EDIT_CFG_ICU_RENAMING_VERSION value at runtime. The way it does this is not officially supported by ICU and as such is not recommended to be relied upon. Enabled by default on UNIX (excluding macOS) if no other options are set.

To test your settings, run cargo test again but with the --ignored flag. For instance:

`1`	`cargo test -- --ignored`

AppFlowy

Fri, 30 May 2025 15:29:53 +0800

AppFlowy-IO/AppFlowy

AppFlowy
⭐️ The Open Source Alternative To Notion ⭐️

AppFlowy is the AI workspace where you achieve more without losing control of your data

Website • Forum • Discord • Reddit • Twitter

User Installation

Download AppFlowy Desktop (macOS, Windows, and Linux)
Other channels: FlatHub, Snapcraft, Sourceforge
Available on
- App Store: iPhone
- Play Store: Android 10 or above; ARMv7 is not supported
Self-hosting AppFlowy
Source

Built With

Flutter
Rust

Stay Up-to-Date

Getting Started with development

Please view the documentation for OS specific development instructions

Roadmap

If you’d like to propose a feature, submit a feature request here
If you’d like to report a bug, submit a bug report here

Releases

Please see the changelog for more details about a given release.

Contributing

Contributions make the open-source community a fantastic place to learn, inspire, and create. Any contributions you make are greatly appreciated. Please look at Contributing to AppFlowy for details.

If your Pull Request is accepted as it fixes a bug, adds functionality, or makes AppFlowy’s codebase significantly easier to use or understand, Congratulations! If your administrative and managerial work behind the scenes sustains the community, Congratulations! You are now an official contributor to AppFlowy.

Translations 🌎🗺

To add translations, you can manually edit the JSON translation files in /frontend/resources/translations, use the inlang online editor, or run npx inlang machine translate to add missing translations.

Join the community to build AppFlowy together

Why Are We Building This?

Notion has been our favourite project and knowledge management tool in recent years because of its aesthetic appeal and functionality. Our team uses it daily, and we are on its paid plan. However, as we all know, Notion has its limitations. These include weak data security and poor compatibility with mobile devices. Likewise, alternative collaborative workplace management tools also have their constraints.

The limitations we encountered using these tools and our past work experience with collaborative productivity tools have led to our firm belief that there is a glass ceiling on what’s possible for these tools in the future. This emanates from the fact that these tools will probably struggle to scale horizontally at some point and be forced to prioritize a proportion of customers whose needs differ from the rest. While decision-makers want a workplace OS, it is impossible to come up with a one-size fits all solution in such a fragmented market.

When a customer’s evolving core needs are not satisfied, they either switch to another or build one from the ground up, in-house. Consequently, they either go under another ceiling or buy an expensive ticket to learn a hard lesson. This is a requirement for many resources and expertise, building a reliable and easy-to-use collaborative tool, not to mention the speed and native experience. The same may apply to individual users as well.

All these restrictions necessitate our mission - to make it possible for anyone to create apps that suit their needs well.

To individuals, we would like to offer Notion’s functionality, data security, and cross-platform native experience.
To enterprises and hackers, AppFlowy is dedicated to offering building blocks and collaboration infra services to enable you to make apps on your own. Moreover, you have 100% control of your data. You can design and modify AppFlowy your way, with a single codebase written in Flutter and Rust supporting multiple platforms armed with long-term maintainability.

We decided to achieve this mission by upholding the three most fundamental values:

Data privacy first
Reliable native experience
Community-driven extensibility

We do not claim to outperform Notion in terms of functionality and design, at least for now. Besides, our priority doesn’t lie in more functionality at the moment. Instead, we would like to cultivate a community to democratize the knowledge and wheels of making complex workplace management tools while enabling people and businesses to create beautiful things on their own by equipping them with a versatile toolbox of building blocks.

License

Distributed under the AGPLv3 License. See LICENSE.md for more information.

Acknowledgments

Special thanks to these amazing projects which help power AppFlowy:

typescript-go

Wed, 28 May 2025 15:29:20 +0800

microsoft/typescript-go

TypeScript 7

Not sure what this is? Read the announcement post!

Preview

A preview build is available on npm as @typescript/native-preview.

1
2

npm install @typescript/native-preview
npx tsgo # Use this as you would tsc.

A preview VS Code extension is available on the VS Code marketplace.

To use this, set this in your VS Code settings:

1
2
3

{
    "typescript.experimental.useTsgo": true
}

How to Build and Run

This repo uses Go 1.24 or higher, Rust 1.85 or higher, Node.js with npm, and hereby.

For tests and code generation, this repo contains a git submodule to the main TypeScript repo pointing to the commit being ported. When cloning, you’ll want to clone with submodules:

`1`	`git clone --recurse-submodules https://github.com/microsoft/typescript-go.git`

If you have already cloned the repo, you can initialize the submodule with:

`1`	`git submodule update --init --recursive`

With the submodule in place and npm ci, you can run tasks via hereby, similar to the TypeScript repo:

hereby build          # Verify that the project builds
hereby test           # Run all tests
hereby install-tools  # Install additional tools such as linters
hereby lint           # Run all linters
hereby format         # Format all code
hereby generate       # Generate all Go code (e.g. diagnostics, committed to repo)

Additional tasks are a work in progress.

hereby is not required to work on the repo; the regular go tooling (e.g., go build, go test ./...) will work as expected. hereby tasks are provided as a convenience for those familiar with the TypeScript repo.

Running `tsgo`

After running hereby build, you can run built/local/tsgo, which behaves mostly the same as tsc.

Running LSP Prototype

To debug and run the VS Code extension without installing it globally:

Run VS Code in the repo workspace (code .)
Copy .vscode/launch.template.json to .vscode/launch.json
F5 (or Debug: Start Debugging from the command palette)

This will launch a new VS Code instance which uses the Corsa LS as the backend. If correctly set up, you should see “tsgo” in the status bar when a TypeScript or JavaScript file is open:

What Works So Far?

This is still a work in progress and is not yet at full feature parity with TypeScript. Bugs may exist. Please check this list carefully before logging a new issue or assuming an intentional change.

Feature	Status	Notes
Program creation	done	Same files and module resolution as TS5.8. Not all resolution modes supported yet.
Parsing/scanning	done	Exact same syntax errors as TS5.8
Commandline and `tsconfig.json` parsing	mostly done	Entry point slightly different for now
Type resolution	done	Same types as TS5.8
Type checking	done	Same errors, locations, and messages as TS5.8. Types printback in errors may display differently (in progress)
JavaScript-specific inference and JS Doc	not ready	-
JSX	done	-
Declaration emit	not ready	Coming soon
Emit (JS output)	in progress	`target: esnext` well-supported, other targets may have gaps
Watch mode	prototype	Watches files and rebuilds, but no incremental rechecking
Build mode / project references	not ready	-
Incremental build	not ready	-
Language service (LSP)	prototype	Minimal functionality (errors, hover, go to def). More features coming soon
API	not ready	-

Definitions:

done aka “believed done”: We’re not currently aware of any deficits or major left work to do. OK to log bugs
in progress: currently being worked on; some features may work and some might not. OK to log panics, but nothing else please
prototype: proof-of-concept only; do not log bugs
not ready: either haven’t even started yet, or far enough from ready that you shouldn’t bother messing with it yet

Other Notes

Long-term, we expect that this repo and its contents will be merged into microsoft/TypeScript. As a result, the repo and issue tracker for typescript-go will eventually be closed, so treat discussions/issues accordingly.

For a list of intentional changes with respect to TypeScript 5.7, see CHANGES.md.

Contributing

This project welcomes contributions and suggestions. Most contributions require you to agree to a Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us the rights to use your contribution. For details, visit Contributor License Agreements.

When you submit a pull request, a CLA bot will automatically determine whether you need to provide a CLA and decorate the PR appropriately (e.g., status check, comment). Simply follow the instructions provided by the bot. You will only need to do this once across all repos using our CLA.

This project has adopted the Microsoft Open Source Code of Conduct. For more information see the Code of Conduct FAQ or contact opencode@microsoft.com with any additional questions or comments.

Trademarks

This project may contain trademarks or logos for projects, products, or services. Authorized use of Microsoft trademarks or logos is subject to and must follow Microsoft’s Trademark & Brand Guidelines. Use of Microsoft trademarks or logos in modified versions of this project must not cause confusion or imply Microsoft sponsorship. Any use of third-party trademarks or logos are subject to those third-party’s policies.

limbo

Mon, 19 May 2025 15:30:44 +0800

tursodatabase/limbo

Project Limbo

Limbo is a project to build the modern evolution of SQLite.

Features and Roadmap

Limbo is a work-in-progress, in-process OLTP database engine library written in Rust that has:

Asynchronous I/O support on Linux with io_uring
SQLite compatibility [doc] for SQL dialect, file formats, and the C API
Language bindings for JavaScript/WebAssembly, Rust, Go, Python, and Java
OS support for Linux, macOS, and Windows

In the future, we will be also working on:

Integrated vector search for embeddings and vector similarity.
BEGIN CONCURRENT for improved write throughput.
Improved schema management including better ALTER support and strict column types by default.

Getting Started

💻 Command Line

You can install the latest `limbo` release with:

1
2

curl --proto '=https' --tlsv1.2 -LsSf \
  https://github.com/tursodatabase/limbo/releases/latest/download/limbo_cli-installer.sh | sh

Then launch the shell to execute SQL statements:

Limbo
Enter ".help" for usage hints.
Connected to a transient in-memory database.
Use ".open FILENAME" to reopen on a persistent database
limbo> CREATE TABLE users (id INT PRIMARY KEY, username TEXT);
limbo> INSERT INTO users VALUES (1, 'alice');
limbo> INSERT INTO users VALUES (2, 'bob');
limbo> SELECT * FROM users;
1|alice
2|bob

You can also build and run the latest development version with:

`1`	`cargo run`

🦀 Rust

`1`	`cargo add limbo`

Example usage:

let db = Builder::new_local("sqlite.db").build().await?;
let conn = db.connect()?;

let res = conn.query("SELECT * FROM users", ()).await?;

✨ JavaScript

`1`	`npm i limbo-wasm`

Example usage:

import { Database } from 'limbo-wasm';

const db = new Database('sqlite.db');
const stmt = db.prepare('SELECT * FROM users');
const users = stmt.all();
console.log(users);

🐍 Python

`1`	`pip install pylimbo`

Example usage:

import limbo

con = limbo.connect("sqlite.db")
cur = con.cursor()
res = cur.execute("SELECT * FROM users")
print(res.fetchone())

🐹 Go

Clone the repository
Build the library and set your LD_LIBRARY_PATH to include limbo’s target directory

1
2

cargo build --package limbo-go
export LD_LIBRARY_PATH=/path/to/limbo/target/debug:$LD_LIBRARY_PATH

Use the driver

1
2

go get github.com/tursodatabase/limbo
go install github.com/tursodatabase/limbo

Example usage:

import (
    "database/sql"
    _"github.com/tursodatabase/limbo"
)

conn, _ = sql.Open("sqlite3", "sqlite.db")
defer conn.Close()

stmt, _ := conn.Prepare("select * from users")
defer stmt.Close()

rows, _ = stmt.Query()
for rows.Next() {
    var id int
    var username string
    _ := rows.Scan(&id, &username)
    fmt.Printf("User: ID: %d, Username: %s\n", id, username)
}

☕️ Java

We integrated Limbo into JDBC. For detailed instructions on how to use Limbo with java, please refer to the README.md under bindings/java.

Contributing

We’d love to have you contribute to Limbo! Please check out the contribution guide to get started.

FAQ

How is Limbo different from Turso’s libSQL?

Limbo is a project to build the modern evolution of SQLite in Rust, with a strong open contribution focus and features like native async support, vector search, and more. The libSQL project is also an attempt to evolve SQLite in a similar direction, but through a fork rather than a rewrite.

Rewriting SQLite in Rust started as an unassuming experiment, and due to its incredible success, replaces libSQL as our intended direction. At this point, libSQL is production ready, Limbo is not - although it is evolving rapidly. As the project starts to near production readiness, we plan to rename it to just “Turso”. More details here.

Publications

Pekka Enberg, Sasu Tarkoma, Jon Crowcroft Ashwin Rao (2024). Serverless Runtime / Database Co-Design With Asynchronous I/O. In EdgeSys ‘24. [PDF]
Pekka Enberg, Sasu Tarkoma, and Ashwin Rao (2023). Towards Database and Serverless Runtime Co-Design. In CoNEXT-SW ’23. [PDF] [Slides]

License

This project is licensed under the MIT license.

Contribution

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in Limbo by you, shall be licensed as MIT, without any additional terms or conditions.

Contributors

Thanks to all the contributors to Limbo!