Expand description
Minimum support: Rust 1.74+.
Visit the site π — Read the book π
The Rune Language, an embeddable dynamic programming language for Rust.
Β§Contributing
If you want to help out, please have a look at Open Issues.
Β§Highlights of Rune
- Runs a compact representation of the language on top of an efficient stack-based virtual machine.
- Clean Rust integration π».
- Memory safe through reference counting π.
- Awesome macros π.
- Template literals π.
- Try operators π.
- Pattern matching π.
- Structs and enums π with associated data and functions.
- Dynamic vectors π, objects π, and tuples π with out-of-the-box serde support π».
- First-class async support π.
- Generators π.
- Dynamic instance functions π.
- Stack isolation π between function calls.
Β§Rune scripts
You can run Rune programs with the bundled CLI:
cargo run --bin rune -- run scripts/hello_world.rn
If you want to see detailed diagnostics of your program while itβs running, you can use:
cargo run --bin rune -- run scripts/hello_world.rn --dump-unit --trace --dump-vm
See --help
for more information.
Β§Running scripts from Rust
You can find more examples in the
examples
folder.
The following is a complete example, including rich diagnostics using
termcolor
. It can be made much simpler if this is not needed.
use rune::{Context, Diagnostics, Source, Sources, Vm};
use rune::termcolor::{ColorChoice, StandardStream};
use std::sync::Arc;
let context = Context::with_default_modules()?;
let runtime = Arc::new(context.runtime()?);
let mut sources = Sources::new();
sources.insert(Source::memory("pub fn add(a, b) { a + b }")?);
let mut diagnostics = Diagnostics::new();
let result = rune::prepare(&mut sources)
.with_context(&context)
.with_diagnostics(&mut diagnostics)
.build();
if !diagnostics.is_empty() {
let mut writer = StandardStream::stderr(ColorChoice::Always);
diagnostics.emit(&mut writer, &sources)?;
}
let unit = result?;
let mut vm = Vm::new(runtime, Arc::new(unit));
let output = vm.call(["add"], (10i64, 20i64))?;
let output: i64 = rune::from_value(output)?;
println!("{}", output);
Re-exports§
pub use self::runtime::from_value;
pub use self::runtime::to_value;
pub use self::runtime::FromValue;
pub use self::runtime::ToValue;
pub use self::runtime::Unit;
pub use self::runtime::Value;
pub use self::runtime::Vm;
pub use self::source::Source;
pub use ::codespan_reporting::term::termcolor;
emit
Modules§
- The Rune core allocation and collections library
- Abstract syntax trees for the Rune language.
- cli
cli
Helper to build customized commandline interfaces using custom rune contexts. - The Rune compiler.
- Diagnostics module for Rune.
- doc
doc
Helper to generate documentation from a context. - Utility for building a language server.
- The macro system of Rune.
- Types used for defining native modules.
- Public packages that can be used to provide extract functionality to virtual machines.
- Parsing utilities for Rune.
- Lazy query system, used to compile and build items on demand and keep track of whatβs being used and not.
- Runtime module for Rune.
- Module for dealing with sources.
- workspace
workspace
Types for dealing with workspaces of rune code.
Macros§
- Helper macro to reference a specific token kind, or short sequence of kinds.
- Helper macro to reference a specific token.
- Helper macro to define a collection of sources populatedc with the given entries.
- Helper to cause a panic.
- Helper to perform the try operation over
VmResult
. - Helper macro to perform a
write!
in a context which errors withVmResult
and returnsVmResult<Result<_, E>>
on write errors.
Structs§
- High level helper for setting up a build of Rune sources into a Unit.
- Error raised when we failed to load sources.
- Context used for the Rune language.
- Structure to collect compilation diagnostics.
- The primitive hash that among other things is used to reference items, types, and native functions.
- A Module that is a collection of native functions and types.
- Options that can be provided to the compiler.
- Helper to register a parameterized function.
- The opaque identifier of a source file, as returned by
Sources::insert
. - A collection of source files.
Enums§
- An error raised when building the context.
Traits§
- A trait which can be stored inside of an AnyObj.
- Helper trait used to convert a type into a type hash.
Functions§
- Entry point to building Sources of Rune using the default unit storage.
Attribute Macros§
- Macro used to annotate native functions which can be loaded into rune.
- Macro used to annotate a module with metadata.