https://github.com/atelierarith/rustcall.jl
It's the last call for headache.
https://github.com/atelierarith/rustcall.jl
aigenerated julia rust
Last synced: 2 days ago
JSON representation
It's the last call for headache.
- Host: GitHub
- URL: https://github.com/atelierarith/rustcall.jl
- Owner: AtelierArith
- License: mit
- Created: 2026-01-09T02:07:29.000Z (6 months ago)
- Default Branch: main
- Last Pushed: 2026-04-25T06:30:00.000Z (about 2 months ago)
- Last Synced: 2026-04-25T07:27:03.521Z (about 2 months ago)
- Topics: aigenerated, julia, rust
- Language: Julia
- Homepage: https://atelierarith.github.io/RustCall.jl/
- Size: 4.68 MB
- Stars: 19
- Watchers: 0
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- Changelog: CHANGELOG.md
- License: LICENSE
- Agents: AGENTS.md
Awesome Lists containing this project
README
# RustCall.jl
[](https://github.com/atelierarith/RustCall.jl/actions/workflows/CI.yml)
RustCall.jl is a Julia package for calling Rust code directly. It covers the common paths from this repository: inline Rust via `rust"""..."""`, explicit FFI calls with `@rust`, lightweight inline expressions with `@irust`, `#[julia]`-based wrapper generation, and external crate loading with `@rust_crate`.
It is inspired by [Cxx.jl](https://github.com/JuliaInterop/Cxx.jl), but targets Rust.
## Installation
Requirements:
- Julia 1.12 or later
- Rust toolchain (`rustc` and `cargo`) available in `PATH`
```julia
using Pkg
Pkg.add("RustCall")
```
RustCall.jl is registered in Julia's General registry. `Pkg.add("RustCall")` installs the package and builds the helper library used by ownership-related features such as `RustBox`, `RustRc`, `RustArc`, `RustVec`, and `RustSlice`.
If the helper library needs to be rebuilt, run:
```julia
using Pkg
Pkg.build("RustCall")
```
## Quick Start
The simplest path is to annotate Rust functions with `#[julia]` and call the generated Julia wrapper directly.
```julia
using RustCall
rust"""
#[julia]
fn add(a: i32, b: i32) -> i32 {
a + b
}
"""
add(10, 20) # 30
```
If you want explicit C-ABI style calls, use `@rust`.
```julia
using RustCall
rust"""
#[no_mangle]
pub extern "C" fn multiply(a: i32, b: i32) -> i32 {
a * b
}
"""
@rust multiply(Int32(6), Int32(7))::Int32 # 42
```
For small expressions inside Julia functions, `@irust` captures Julia variables with `$var`.
```julia
using RustCall
function affine(a, x, b)
@irust("\$a * \$x + \$b")
end
affine(Int32(2), Int32(10), Int32(3)) # 23
```
## Main APIs
- `rust"""..."""` / `@rust_str`: compile Rust code, cache the build artifact, and make it available in the current Julia module
- `#[julia]`: generate Julia-callable wrappers for Rust functions and structs
- `@rust`: call exported functions through a C-compatible ABI
- `@irust`: compile a small Rust expression with Julia variable capture
- `@rust_crate`: build and load an external crate annotated with `#[julia]`
- `@rust_llvm`: experimental LLVM-based call path
Rust dependencies can be declared inline with `// cargo-deps:` or fenced `cargo` blocks. The first build may need network access.
## External Crates
`@rust_crate` loads a Rust crate and returns a Julia module-like binding object.
```julia
using RustCall
const MyCrate = @rust_crate "/path/to/my_crate"
MyCrate.add(Int32(1), Int32(2)) # 3
```
For crate-side bindings, use the companion `juliacall_macros` crate and mark exported items with `#[julia]`.
## Documentation And Examples
- Documentation:
- Examples: [`examples/`](examples)
- Tutorial source: [`docs/src/tutorial.md`](docs/src/tutorial.md)
- API reference source: [`docs/src/api.md`](docs/src/api.md)
- Troubleshooting source: [`docs/src/troubleshooting.md`](docs/src/troubleshooting.md)
## Development
For a local checkout:
```bash
julia --project -e 'using Pkg; Pkg.instantiate()'
julia --project -e 'using Pkg; Pkg.build("RustCall")'
julia --project -e 'using Pkg; Pkg.test()'
julia --project=docs docs/make.jl
```
The main package entry point is `src/RustCall.jl`. Runnable examples live in `examples/`.
## Acknowledgments
RustCall.jl has been implemented with support from AI coding tools and agents including Codex, Claude Code, and Cursor.