Thank you!!
From an extremely brief scan, it appears that Erlang wrappers around SQLite should be able to use the Graft SQLite extension just fine.
Alternatively, it would be reasonably straight forward to wrap Graft Client (Rust library) directly in an Erlang NIF using something like https://github.com/rusterlium/rustler
Let's make it happen! :)
In Stop syncing everythingrusterlium
rustler
Rust2016–2025
rusterlium / rustler
rustler
Safe Rust bridge for creating Erlang NIF functions
49Distinct people
58Mentions
0Explicit recommenders
4.9KGitHub stars
What to know before exploring
What it is
Safe Rust bridge for creating Erlang NIF functions
GitHub
Where it is used
No documented product use was verified in the last source check.
What people are saying
No recommendation phrase was found in the indexed comments.
No classified warning is attached to this page. Read the discussions before treating silence as approval.
Also in these discussions
- elixir-nx/axon · linked in 2 of the same discussions
- elixir-nx/nx · linked in 2 of the same discussions
- neon-bindings/neon · linked in 2 of the same discussions
Mentioned in the same Hacker News threads. That is not proof they are substitutes.
This week on Hacker News
Nov 7–Nov 14 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/14/2026, 3:56:07 PM UTC.
No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.
Mentions over time
HN mentions by year58 dated mentions
Observed mentions: 2016-03-04 08:03:43 UTC to 2025-04-02 13:15:02 UTC.
Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.
View mention counts and date ranges
| Period | Start (UTC) | End (exclusive, UTC) | Mentions | Submissions | Comments |
|---|---|---|---|---|---|
| 2016 | 2016-01-01 00:00:00 UTC | 2017-01-01 00:00:00 UTC | 10 | 2 | 8 |
| 2017 | 2017-01-01 00:00:00 UTC | 2018-01-01 00:00:00 UTC | 5 | 0 | 5 |
| 2018 | 2018-01-01 00:00:00 UTC | 2019-01-01 00:00:00 UTC | 7 | 0 | 7 |
| 2019 | 2019-01-01 00:00:00 UTC | 2020-01-01 00:00:00 UTC | 7 | 1 | 6 |
| 2020 | 2020-01-01 00:00:00 UTC | 2021-01-01 00:00:00 UTC | 6 | 0 | 6 |
| 2021 | 2021-01-01 00:00:00 UTC | 2022-01-01 00:00:00 UTC | 4 | 1 | 3 |
| 2022 | 2022-01-01 00:00:00 UTC | 2023-01-01 00:00:00 UTC | 5 | 0 | 5 |
| 2023 | 2023-01-01 00:00:00 UTC | 2024-01-01 00:00:00 UTC | 5 | 0 | 5 |
| 2024 | 2024-01-01 00:00:00 UTC | 2025-01-01 00:00:00 UTC | 7 | 0 | 7 |
| 2025 | 2025-01-01 00:00:00 UTC | 2026-01-01 00:00:00 UTC | 2 | 0 | 2 |
From the project README
An excerpt from the repository, fetched Nov 13, 2026.
Read the project’s introduction
Rustler
Documentation | Getting Started | Example
Rustler is a library for writing Erlang NIFs in safe Rust code. That means
there should be no ways to crash the BEAM (Erlang VM). The library provides
facilities for generating the boilerplate for interacting with the BEAM,
handles encoding and decoding of Erlang terms, and catches rust panics before
they unwind into C.
The library provides functionality for both Erlang and Elixir, however Elixir
is favored as of now.
Features
Safety
The code you write in a Rust NIF should never be able to crash the BEAM.
Interop
Decoding and encoding rust values into Erlang terms is as easy as a function call.
Type composition
Making a Rust struct encodable and decodable to Erlang or Elixir can be done with a single attribute.
Resource objects
Enables you to safely pass a reference to a Rust struct into Erlang code. The struct will be automatically dropped when it's no longer referenced.
Getting started
The easiest way of getting started is the rustler Elixir library.
Add the rustler Elixir library as a
dependency of your project.
Run mix rustler.new to generate a new NIF in your project. Follow the
instructions.
If you are already using serde and/or have been using
serde_rustler before, please enable the serde feature in your NIF crate's
Cargo.toml on the rustler dependency.
What it looks like
This is the code for a minimal NIF that adds two numbers and returns the result.
#[rustler::nif]
fn add(a: i64, b: i64) -> i64 {
a + b
}
rustler::init!("Elixir.Math");
Minimal Supported Rust Version (MSRV)
Rustler currently has a minimal supported Rust version (MSRV) of 1.91. This
is the configured version in .clippy.toml.
Supported OTP and Elixir Versions
Rustler aims to support the newest three major OTP versions as well as newest three minor Elixir versions.
Supported NIF version
The minimal supported NIF version for a library should be defined via Cargo
features. The default is currently 2.17 (Erlang/OTP 26).
To use features from NIF version 2.18 (Erlang/OTP 29), the respective feature
flag has to be enabled on the dependency:
[dependencies]
rustler = { version = "...", features = ["nif_version_2_18"] }
To target an older NIF version, disable default features and explicitly enable
the required version:
[dependencies]
rustler = { version = "...", default-features = false, features = ["nif_version_2_15"] }
Community
You can find us in the #rustler:matrix.org channel on Matrix
or in the #rustler channel in the Elixir lang Slack.
License
Licensed under either of
Apache License, Version 2.0, (LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0)
MIT license (LICENSE-MIT or http://opensource.org/licenses/MIT)
at your option.
Contribution
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.
Read the full README on GitHubWhat Hacker News says
58 sourcesRustler actually wraps the NIF and passes the exception back to the caller
> The library provides facilities for generating the boilerplate for interacting with the BEAM, handles encoding and decoding of Erlang terms, and catches rust panics before they unwind into C.
https://github.com/rusterlium/rustler
In Parsing PDFs (and more) in Elixir using RustI personally find actors in rust to be too much of a head ache. You might as well use Erlang (or elixir) and do your heaving lifting in rust with somethign like https://github.com/rusterlium/rustler
In Ractor – a Rust Actor FrameworkI believe that by using rustler[0] to build the bindings that shouldn't be possible. (at the very least that's stated in the readme.)
> Safety : The code you write in a Rust NIF should never be able to crash the BEAM.
I tried to find some documentation stating how it works but couldn't. I think they use a dirty scheduler, and catch panics at the boundaries or something? wasn't able to find a clear reference.
[0] https://github.com/rusterlium/rustler
In Using Rust in non-Rust servers to improve performanceDo you mean Rustler?
Yes, it's Apache 2.0
https://github.com/rusterlium/rustler
In Zigler: Zig NIFs in ElixirYep, I think you'd be hard-pressed to find the actual Elixir code to be the bottleneck in a real-life application. But if you do encounter that, you can use something like Rustler[0] for the CPU-intensive bottleneck, as Discord did[1] while working on a data structure they needed. Slow DB queries are something else to look out for.
edit: Didn't see Rustler was already mentioned in a sibling thread, but hopefully the Discord tidbit will be interesting to others.
[0] https://github.com/rusterlium/rustler
[1] https://github.com/discord/sorted_set_nif
In Ask HN: What is the best way to learn Erlang?Well, it depends on the bottleneck. CPU-bound code, I would of course agree. For I/O bound though, especially network I/o with variable peers (which is the vast majority of code written nowadays) erlang's concurrency model is fantastic.
Also worth mentioning is that you can write CPU intensive code in rust and invoke it as NIFs[1]
[1] https://github.com/rusterlium/rustler
In Ask HN: What is the best way to learn Erlang?Complex Rust types are absolutely supported with Rustler. And with one command I can have Elixir pull a Rust crate and do 80% of the work setting it up for me to be able to use it in a project.
https://github.com/rusterlium/rustler
In Exploring Gleam, a type-safe language on the BEAMFor performance intensive tasks, you could rely on Rust NIFs, there is this great project: https://github.com/rusterlium/rustler
My last project with Elixir was using Elixir merely as an orchestrator of static binaries (developed in golang) which were talking in JSON via stdin/stdout.
In AI Toolkit: Give a brain to your game's NPCs, a header-only C++ libraryThanks for your insights as always.
Related to (b), any thoughts on Rustler?
My understanding it’s used extensively at Discord to eliminate Erlang/OTP performance bottlenecks.
https://github.com/rusterlium/rustler
In Ask HN: Good examples of fault-tolerant Erlang code?Elixir/Rust is the new Python/C++, and Rustler makes the communicating between the 2 languages super easy: https://github.com/rusterlium/rustler
In Maybe Rust isn’t a good tool for massively concurrent, userspace softwareElixir C interop is actually pretty pleasant. After Java I was expecting it to be a nightmare, but it was shockingly easy and well though out.
The big thing in Elixir community right now is to write the native/performance code in Rust[1] and interop with Elixir.
[1]: https://github.com/rusterlium/rustler
In Elixir – Why the dot when calling anonymous functions?> I guess, why not use Rust entirely instead of as a FFI into Elixir or other backend language?
Because Rust brings none of the benefits of the BEAM ecosystem to the table.
I was an early Elixir adopter, not working currently as an Elixir developer, but I have deployed one of the largest Elixir applications for a private company in my country.
I know it has limits, but the language itself is only a small part of the whole.
Take ML, Jose Valim and Sean Moriarity have studied the problem, made a plan to tackle it and started solving it piece by piece [1] in a tightly integrated manner, it feels natural, as if Elixir always had those capabilities in a way that no other language does and to put the icing on the cake the community released Livebook [2] to interactively explore code and use the new tools in the simplest way possible, something
Read the rest
that Python notebooks only dream of being capable of, after a decade of progress
But they do not not stop there, the documentation is always of very high quality, even for stuff not coming from the core developers, and they also regularly release educational material that is worth a hundred times a gain in speed.
They've set a very high quality standard and I noticed how much it is important only when I stopped programming daily in Elixir and went back to other more hyped or establish ecosystems.
That's not to say that Elixir is superior as a language, but that the ecosystem is flourishing and the community is able to extract the 100% of the benefits from the tools and create new marvellously crafted ones, that push the limits forward every time, in such a simple manner, that it looks like magic.
Going back to Rust, you can write Rust if you need speed or for whatever reason you feel it's the right tool for the job, it's totally integrated [3][4], again in a way that many other languages can only dream of, and it's in fact the reason I've learned Rust in the first place.
I must also say that the work done by the Rust community looks refreshing as well, if you look at the way rustler works it was very well thought and made writing NIFs, something that seemed arcane and distant, only for the proverbial mad professor to try, a breeze. Kudos to them.
But the opposite IMO is not true, if you write Rust, you write Rust, and that's it. You can't take advantage of the many features the BEAM offers, OTP, hot code reloading, full inspection of running systems, distribution, scalability, fault tolerance, soft real time etc. etc. etc.
But of course if you don't see any advantage in them, it means you probably don't need them (one other option is that you still don't know you want them :] ). In that case Rust is as good as any other language, but for a backend, even though I gently despise it, Java (or Kotlin) might be a better option.
[1] https://github.com/elixir-nx/nx https://github.com/elixir-nx/axon
[2] https://livebook.dev/
[3] https://github.com/rusterlium/rustler
[4] https://dashbit.co/blog/rustler-precompiled
One thing that drew me to Rust was actually Elixir/Erlang calling out to it for certain specialized needs. Within Elixir/Erlang you get best of breed concurrency but exiting the BEAM to run other code is unsafe. Calling out to Rust, however, comes with great safety guarantees.
Managing concurrency outside of Rust and then calling Rust for the more focused and specialized work is a good combination IMO.
https://github.com/rusterlium/rustler
In When Rust hurtsYes, for CPU bound processed on the BEAM you'll want to use a NIF (native implemented function) but that leaves you open to taking down the entire VM with bad NIF code (segfaults, infinite loops, etc). A purported safer means to create NIFs is to use Rustler (https://github.com/rusterlium/rustler) which lets you easily write NIFs in Rust instead of C. I haven't used it but I've heard good things.
In Plane: Per-user backends for web appsShowing the 15 most recent of 58 sources. Enable JavaScript to search and browse every indexed mention.