mrkeyoor.com_
Sat 26 Sept 16:10 UTC
Dataevaluationupdated 26 Sept 2026

toasty review

Toasty is an asynchronous Rust ORM that generates database operations from annotated Rust structs. It supports SQL databases and DynamoDB while exposing what each backend can actually do instead of pretending every database has the same query model. Its main promise is to catch unsupported access patterns in generated code before they become inefficient production queries.

Verdict

Our Toasty build took 279 seconds, then cargo test ran 274 seconds before integration-suite compilation failed, so teams should trial v0.11 on their own backend before adoption. The database-aware generated API is a serious idea, especially for Rust applications crossing SQL and DynamoDB, but the 0.11 breaking changes and unscheduled roadmap make Toasty an early-adopter choice. Use it for a new service you can test deeply, not as a hurried replacement for a settled production data layer.

We ran it

Lab card: what happened when we ran toastyScreenshot of toasty (github.com/tokio-rs/toasty)
Install✓ · 25s216 packages
Build✓ · 279s
Tests✗ · 274sran, no count parsed
Repo1115 files~171,307 lines of source · 6.6 MB · 6 CI workflows · tests dir

Answers from our run

Does toasty build from source?

Dependencies installed in 25 seconds (216 packages), and the build succeeded in 279 seconds. We cloned commit 6a1f5d9 into a clean Debian container with 3 CPUs and no project-specific setup.

Do toasty's tests pass?

The test command failed in our container, and its output did not report a pass or fail count.

Who should not use toasty?

Teams that require the repository's default test command to pass in a fresh container: our run stopped while compiling toasty-driver-integration-suite, and the log tail did not include the compiler diagnostic.

What are the alternatives to toasty?

SeaORM, Diesel, SQLx. Our Toasty build took 279 seconds, then cargo test ran 274 seconds before integration-suite compilation failed, so teams should trial v0.

Setup2/525-second install, 279-second build, then test compilation failed
Docs4/5Detailed guide covers backends, models, pools, and migrations
Community4/53,158 stars with active releases, issues, and merged pull requests
Maturity3/5Six backends exist, but v0.11 still carries breaking changes

Who it’s for

Rust teams building on Tokio that want generated model APIs and async database access.
Applications that may use SQLite, Turso, PostgreSQL, MySQL, MariaDB, or DynamoDB and can accept backend-specific capabilities.
Developers willing to adopt Rust 1.95 and review generated migrations before applying them.
Early adopters who can test their exact relationships and query patterns against Toasty 0.11.

Who it’s NOT for

Teams that require the repository's default test command to pass in a fresh container: our run stopped while compiling toasty-driver-integration-suite, and the log tail did not include the compiler diagnostic.
Projects pinned below Rust 1.95: the workspace declares 1.95 as its minimum toolchain.
Applications that need many-to-many relationships, aggregates, manual SQL transactions, or row-level locking today: those appear on the roadmap, which explicitly says listed work is not scheduled or imminent.
Buyers who need a stable upgrade surface: v0.11 includes breaking model-field, Turso, MySQL bulk-insert, and generated-column changes.
Developers who want one identical query language across every backend: Toasty intentionally generates operations according to each database's capabilities.
Small SQL services whose team already prefers handwritten queries: SQLx offers a narrower path without adopting Toasty's model and migration conventions.

Setup reality

Our sandbox installed 216 packages in 25 seconds, then completed the build in 279 seconds. cargo test ran for 274 seconds and failed with exit code 101 while compiling toasty-driver-integration-suite. The log tail showed the rustc process exiting unsuccessfully and other jobs waiting, but it did not include the compiler diagnostic, so we cannot name the cause.

Toasty 0.11 requires Rust 1.95. A basic SQLite app enables the sqlite feature and needs Tokio. Other drivers require their own feature, connection URL, credentials, and running service. DynamoDB uses AWS configuration from the environment, while Turso serverless accepts an authentication token.

The repository includes a compose file and a large integration suite for its drivers. Production migrations require adding toasty-cli, creating a small project-specific CLI binary, and committing generated SQL, snapshots, and history. The 1,115-file workspace has multiple driver crates and examples, so source builds are materially heavier than adding a small query helper.

Toasty generates only the operations a backend can support

Toasty starts with Rust structs marked by #[derive(toasty::Model)]. Field annotations identify keys, generated values, indexes, unique values, and relationships. The macro then creates typed insert and lookup methods. Registering those models gives Toasty enough information to infer tables, indexes, and relations, while Db::builder() connects that model set to a selected driver.

The unusual part is its refusal to flatten every database into one pretend dialect. A SQL driver can allow extra query constraints, while DynamoDB methods are generated around indexed access patterns and sort keys. That can prevent a convenient-looking query from becoming an accidental scan. It also means changing backends can change which methods exist, so portability depends on using the common capability set your application has actually tested.

Version 0.11 covers 6 connection schemes with different behavior

The current database guide documents SQLite, Turso, PostgreSQL, MySQL, MariaDB, and DynamoDB connection schemes. MariaDB support arrived in v0.11 with native UUID columns and INSERT ... RETURNING. A mysql:// URL aimed at the same MariaDB server deliberately keeps MySQL behavior, including different UUID storage. Switching the URL scheme can therefore require a schema migration.

Turso also has two modes. A local path or :memory: uses the embedded engine, while a hosted URL selects the serverless HTTP driver and accepts a token. DynamoDB draws credentials and region details from AWS configuration. Toasty gives these backends a shared model vocabulary, but deployment still requires per-driver TLS, credentials, connection limits, and failure testing.

What happened when we ran it

Our sandbox installed 216 packages in 25 seconds. The full source build succeeded after 279 seconds on 3 CPUs with 12 GB of RAM. This was a sizeable checkout: 1,115 files, about 171,307 source lines, and 6.6 MB before dependencies. Six CI workflow files, a compose file, and a tests directory were present.

The test step did not pass. After 274 seconds, cargo test exited 101 while rustc was compiling toasty-driver-integration-suite. The tail also showed example and fixture crates compiling, followed by a message that other jobs were still finishing. It did not contain the actual compiler diagnostic. Our result supports only the narrow finding that commit 6a1f5d9 built with the lab's build command but failed during test compilation in that fresh container.

That distinction matters for a database library. The repository clearly contains substantial test code and driver-specific CI, yet our default run still failed before producing a test count. A prospective adopter should run the same feature combination, database services, and toolchain intended for production. We would not turn this log into a theory about memory, system packages, or a particular driver because the supplied tail does not show one.

Migrations work, but your application supplies the CLI binary

For prototypes, push_schema() creates tables and indexes directly from registered models. Production use has a migration system that compares current models with a stored snapshot, writes database-specific SQL, and records applied IDs in a __toasty_migrations table. Generated migrations can also be embedded in a compiled application.

There is an extra setup step: Toasty cannot ship a universal standalone generator because migration code needs access to your model types. The guide asks each project to add toasty-cli, create a small binary that registers its models, and keep a Toasty.toml plus migration history. This is defensible Rust architecture, though it is more ceremony than running a global CLI against a schema file. Generated SQL still deserves review before it touches data.

The roadmap names missing query and relationship features

Toasty's roadmap is unusually honest about commitment. It says an entry means maintainers agree the feature should exist, not that work is scheduled, assigned, or imminent. Current entries include many-to-many relations, relation filtering, aggregates, upsert, manual SQL transactions, row locking, full-text search, and several advanced PostgreSQL index types.

Those are normal application requirements, not decorative extras. Issue 1246, for example, reports no method for filtering parents whose optional has_one relation is absent in v0.10. Open engine work in September also covered null semantics and unsupported filter paths. Before choosing Toasty, model 5 or 10 of your hardest real queries and confirm they compile and produce acceptable database operations. A successful quickstart cannot answer that question.

v0.11 activity is high and upgrade work is real

GitHub recorded a push on September 26, 2026, hours after Toasty v0.11.0 was released on September 25. The project had 3,158 stars and 106 open issues and pull requests. Recent changes included relation work, MariaDB, Turso serverless support, dependency updates, documentation, and fixes across the engine. This is active development rather than a dormant experiment.

The release also carries several breaking changes. Newtype accessors were renamed, one enum-backed column pattern changed and needs migration, Turso serverless behavior changed, and MySQL now rejects bulk inserts that depend on inferred auto-increment IDs. That is reasonable movement for a 0.x ORM, but it sets the buyer profile. Toasty fits a new Rust service whose team wants database-aware generated APIs and can absorb change. SeaORM and Diesel offer SQL-oriented ORM alternatives, while SQLx is the cleaner choice when explicit SQL is part of the design.

Alternatives

ProjectWhat it isPick it when
SeaORMAn async Rust ORM focused on relational databases and generated entities.pick this instead when you want an established async SQL ORM and do not need Toasty's DynamoDB model.
DieselA long-running Rust ORM and query builder with compile-time schema checks.pick this instead when ecosystem age and a SQL-focused type system matter more than one model across SQL and NoSQL.
SQLx gh↗An async SQL toolkit with compile-time checked queries and no ORM model layer.pick this instead when your team wants to write SQL directly while retaining compile-time query checks.

What people are saying

  1. [github-trending] tokio-rs/toasty

Sources

  1. Toasty README
  2. Toasty v0.11.0 release
  3. Toasty getting started guide
  4. Toasty schema management guide
  5. Toasty roadmap
  6. Missing optional relation filter issue 1246

More data reviews

gfwlist · simdjson · go-stock · sqlitebrowser · hydradb · DouYin_Spider · the whole board →