- Rust 99.6%
- Shell 0.3%
Bumps [redb](https://github.com/cberner/redb) from 4.4.0 to 4.5.0. <details> <summary>Release notes</summary> <p><em>Sourced from <a href="https://github.com/cberner/redb/releases">redb's releases</a>.</em></p> <blockquote> <h2>4.5.0</h2> <h3>Multi-process support</h3> <p>Database files cannot be shared between processes using these modes and processes using the <code>experimental-multiprocess</code> feature of redb 4.3 or 4.4. Their locking is incompatible, and 4.5 can't detect the older processes.</p> <ul> <li>Add <code>Builder::set_concurrency_mode()</code>, which takes a <code>ConcurrencyMode</code> configuring how processes may share the database.</li> <li><code>ConcurrencyMode::ExclusiveWriter</code> (the default) locks the whole file, as earlier versions do.</li> <li><code>ConcurrencyMode::SingleWriter</code> allows one process to write, and any number of processes may open the database read-only.</li> <li><code>ConcurrencyMode::MultiWriter</code> allows any number of processes to open the database for writing, one write transaction at a time, and any number may open it read-only.</li> </ul> <h3>New features</h3> <ul> <li>Add <code>Builder::open_read_only_with_backend()</code> to open a read-only database from a storage backend.</li> <li>Add <code>Builder::set_check_integrity_on_open()</code>, which verifies the whole file on every <code>open()</code> instead of trusting the state recorded by a clean shutdown.</li> <li>Add <code>ReadOnlyDatabase::close()</code>, which releases the file and its locks without waiting for the read transactions opened from the database to be dropped.</li> <li>Add <code>Database::close()</code>, which closes the database as dropping it does, but returns any error rather than ignoring it.</li> <li>Add <code>Database::try_begin_write()</code>, which returns <code>TransactionError::WouldBlock</code> instead of waiting for an in-progress write transaction to finish.</li> </ul> <h3>Performance</h3> <ul> <li>Operations on tables with <code>&str</code> or <code>String</code> keys are faster.</li> </ul> <h3>Deprecations</h3> <ul> <li><code>Builder::create_file()</code> is deprecated; use <code>Builder::create_with_backend(FileBackend::new(file)?)</code> instead.</li> <li><code>WriteTransaction::print_allocated_page_debug()</code> is deprecated. It is an internal debugging aid, present only in debug builds.</li> </ul> <h3>Bug fixes</h3> <ul> <li><code>open()</code> reports a malformed allocator state as <code>StorageError::Corrupted</code> instead of panicking.</li> <li>Repair and <code>check_integrity()</code> verify the trees kept by persistent savepoints, which were not checked before.</li> <li>Fix <code>cache_stats()</code>, with the <code>cache_metrics</code> feature, panicking in debug builds or returning a <code>write_misses()</code> near <code>u64::MAX</code> in release builds when called while another thread is writing.</li> <li>Repair, <code>check_integrity()</code>, and <code>commit()</code> report some forms of file corruption as <code>StorageError::Corrupted</code> instead of panicking. This cannot occur in normal operation, and only effects database which were externally modified.</li> </ul> </blockquote> </details> <details> <summary>Changelog</summary> <p><em>Sourced from <a href="https://github.com/cberner/redb/blob/master/CHANGELOG.md">redb's changelog</a>.</em></p> <blockquote> <h2>4.5.0 - 2026-11-05</h2> <h3>Multi-process support</h3> <p>Database files cannot be shared between processes using these modes and processes using the <code>experimental-multiprocess</code> feature of redb 4.3 or 4.4. Their locking is incompatible, and 4.5 can't detect the older processes.</p> <ul> <li>Add <code>Builder::set_concurrency_mode()</code>, which takes a <code>ConcurrencyMode</code> configuring how processes may share the database.</li> <li><code>ConcurrencyMode::ExclusiveWriter</code> (the default) locks the whole file, as earlier versions do.</li> <li><code>ConcurrencyMode::SingleWriter</code> allows one process to write, and any number of processes may open the database read-only.</li> <li><code>ConcurrencyMode::MultiWriter</code> allows any number of processes to open the database for writing, one write transaction at a time, and any number may open it read-only.</li> </ul> <h3>New features</h3> <ul> <li>Add <code>Builder::open_read_only_with_backend()</code> to open a read-only database from a storage backend.</li> <li>Add <code>Builder::set_check_integrity_on_open()</code>, which verifies the whole file on every <code>open()</code> instead of trusting the state recorded by a clean shutdown.</li> <li>Add <code>ReadOnlyDatabase::close()</code>, which releases the file and its locks without waiting for the read transactions opened from the database to be dropped.</li> <li>Add <code>Database::close()</code>, which closes the database as dropping it does, but returns any error rather than ignoring it.</li> <li>Add <code>Database::try_begin_write()</code>, which returns <code>TransactionError::WouldBlock</code> instead of waiting for an in-progress write transaction to finish.</li> </ul> <h3>Performance</h3> <ul> <li>Operations on tables with <code>&str</code> or <code>String</code> keys are faster.</li> </ul> <h3>Deprecations</h3> <ul> <li><code>Builder::create_file()</code> is deprecated; use <code>Builder::create_with_backend(FileBackend::new(file)?)</code> instead.</li> <li><code>WriteTransaction::print_allocated_page_debug()</code> is deprecated. It is an internal debugging aid, present only in debug builds.</li> </ul> <h3>Bug fixes</h3> <ul> <li><code>open()</code> reports a malformed allocator state as <code>StorageError::Corrupted</code> instead of panicking.</li> <li>Repair and <code>check_integrity()</code> verify the trees kept by persistent savepoints, which were not checked before.</li> <li>Fix <code>cache_stats()</code>, with the <code>cache_metrics</code> feature, panicking in debug builds or returning a <code>write_misses()</code> near <code>u64::MAX</code> in release builds when called while another thread is writing.</li> <li>Repair, <code>check_integrity()</code>, and <code>commit()</code> report some forms of file corruption as <code>StorageError::Corrupted</code> instead of panicking. This cannot occur in normal operation, and only effects database which were externally modified.</li> </ul> <h2>redb-derive 0.2.0 - 2026-10-13</h2> <ul> <li>Fix <code>#[derive(Value)]</code> and <code>#[derive(Key)]</code> failing to compile on structs whose lifetimes are named <code>'a</code> or <code>'b</code>; the generated implementations no longer shadow the struct's lifetimes.</li> <li>Fix the derived implementations calling inherent methods named <code>fixed_width</code>, <code>from_bytes</code>, <code>as_bytes</code>, or <code>type_name</code> on field types, instead of the <code>Value</code> trait methods. The generated code now uses fully qualified paths, and no longer requires the <code>Value</code> and <code>Key</code> traits to be in scope at the derive site.</li> <li>Add <code>#[redb(crate = "...")]</code> to name the crate the implementations are generated for, when redb is renamed or present in several versions. Structs with fields require redb 3.0+.</li> </ul> <!-- raw HTML omitted --> </blockquote> <p>... (truncated)</p> </details> <details> <summary>Commits</summary> <ul> <li><a href=" |
||
|---|---|---|
| .cargo | ||
| .config | ||
| .github | ||
| .img | ||
| docker | ||
| iroh | ||
| iroh-base | ||
| iroh-dns | ||
| iroh-dns-server | ||
| iroh-relay | ||
| .dockerignore | ||
| .gitattributes | ||
| .gitignore | ||
| .typos.toml | ||
| AI_POLICY.md | ||
| Cargo.lock | ||
| Cargo.toml | ||
| CHANGELOG.md | ||
| CHANGELOG_old.md | ||
| cliff.toml | ||
| code_of_conduct.md | ||
| CONTRIBUTING.md | ||
| deny.toml | ||
| example.config.toml | ||
| LICENSE-APACHE | ||
| LICENSE-MIT | ||
| Makefile.toml | ||
| README.md | ||
| release.toml | ||
| TRANSPORTS.md | ||
less net work for networks
What is iroh?
Iroh gives you an API for dialing by public key. You say “connect to that phone”, iroh will find & maintain the fastest connection for you, regardless of where it is.
Hole-punching
The fastest route is a direct connection, so if necessary, iroh tries to hole-punch. Should this fail, it can fall back to an open ecosystem of public relay servers. To ensure these connections are as fast as possible, we continuously measure iroh.
Built on QUIC
Iroh uses noq to establish QUIC connections between endpoints. This way you get authenticated encryption, concurrent streams with stream priorities, a datagram transport and avoid head-of-line-blocking out of the box.
Compose Protocols
Use pre-existing protocols built on iroh instead of writing your own:
- iroh-blobs for BLAKE3-based content-addressed blob transfer scaling from kilobytes to terabytes
- iroh-gossip for establishing publish-subscribe overlay networks that scale, requiring only resources that your average phone can handle
- iroh-docs for an eventually-consistent key-value store of iroh-blobs blobs
Getting Started
Rust Library
It's easiest to use iroh from rust.
Install it using cargo add iroh, then on the connecting side:
const ALPN: &[u8] = b"iroh-example/echo/0";
let endpoint = Endpoint::bind().await?;
// Open a connection to the accepting endpoint
let conn = endpoint.connect(addr, ALPN).await?;
// Open a bidirectional QUIC stream
let (mut send, mut recv) = conn.open_bi().await?;
// Send some data to be echoed
send.write_all(b"Hello, world!").await?;
send.finish()?;
// Receive the echo
let response = recv.read_to_end(1000).await?;
assert_eq!(&response, b"Hello, world!");
// As the side receiving the last application data - say goodbye
conn.close(0u32.into(), b"bye!");
// Close the endpoint and all its connections
endpoint.close().await;
And on the accepting side:
let endpoint = Endpoint::bind().await?;
let router = Router::builder(endpoint)
.accept(ALPN.to_vec(), Arc::new(Echo))
.spawn()
.await?;
// The protocol definition:
#[derive(Debug, Clone)]
struct Echo;
impl ProtocolHandler for Echo {
async fn accept(&self, connection: Connection) -> Result<()> {
let (mut send, mut recv) = connection.accept_bi().await?;
// Echo any bytes received back directly.
let bytes_sent = tokio::io::copy(&mut recv, &mut send).await?;
send.finish()?;
connection.closed().await;
Ok(())
}
}
The full example code with more comments can be found at echo.rs.
Or use one of the pre-existing protocols, e.g. iroh-blobs or iroh-gossip.
Other Languages
If you want to use iroh from other languages, make sure to check out iroh-ffi, the repository for FFI bindings.
Links
Repository Structure
This repository contains a workspace of crates:
iroh: The core library for hole-punching & communicating with relays.iroh-relay: The relay client and server implementation. This is the code we run in production for the public relays (and you can, too!).iroh-base: Common types likeEndpointIdorRelayUrl.iroh-dns-server: DNS server implementation powering the DNS/Pkarr address lookup for EndpointIds, running at dns.iroh.link.
License
Copyright 2025 N0, INC.
This project is licensed under either of
- Apache License, Version 2.0, (LICENSE-APACHE or https://www.apache.org/licenses/LICENSE-2.0)
- MIT license (LICENSE-MIT or https://opensource.org/licenses/MIT)
at your option.
Contribution
Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in this project by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.