Rust wrapper for ArrayFire

Overview

ci docs book slack github-discussions

Arrayfire Rust Bindings

ArrayFire is a high performance library for parallel computing with an easy-to-use API. It enables users to write scientific computing code that is portable across CUDA, OpenCL and CPU devices. This project provides Rust bindings for the ArrayFire library. Given below table shows the rust bindings compatability with ArrayFire. If you find any bugs, please report them here.

arrayfire-rust ArrayFire
M.m.p1 M.m.p2

Only, Major(M) & Minor(m) version numbers need to match. p1 and p2 are patch/fix updates for arrayfire-rust & ArrayFire respectively, and they don't need to match.

Supported platforms

Linux, Windows and OSX. Rust 1.31 or newer is required.

Use from Crates.io

To use the rust bindings for ArrayFire from crates.io, the following requirements are to be met first.

  1. Download and install ArrayFire binaries based on your operating system. Depending on the method of your installation for Linux, steps (2) & (3) may not be required. If that is the case, proceed to step (4) directly.
  2. Set the evironment variable AF_PATH to point to ArrayFire installation root folder.
  3. Make sure to add the path to lib files to your path environment variables.
    • On Linux: do export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$AF_PATH/lib64
    • On OSX: do export DYLD_LIBRARY_PATH=$DYLD_LIBRARY_PATH:$AF_PATH/lib64
    • On Windows: Add %AF_PATH%\lib to your PATH environment variable.
  4. Add arrayfire = "3.8" to the dependencies section of your project's Cargo.toml file. Make sure to change the version to latest available.

Once step (4) is over, you should be able to use ArrayFire in your Rust project. If you find any bugs, please report them here.

Build from Source

Edit build.conf to modify the build flags. The structure is a simple JSON blob. Currently Rust does not allow key:value pairs to be passed from the CLI. To use an existing ArrayFire installation modify the first three JSON values. You can install ArrayFire using one of the following two ways.

To build arrayfire submodule available in the rust wrapper repository, you have to do the following.

git submodule update --init --recursive
cargo build // use --all to build all crates in the workspace

This is recommended way to build Rust wrapper since the submodule points to the most compatible version of ArrayFire the Rust wrapper has been tested with. You can find the ArrayFire dependencies below.

Example

let num_rows: u64 = 5;
let num_cols: u64 = 3;
let dims = Dim4::new(&[num_rows, num_cols, 1, 1]);
let a = randu::<f32>(dims);
af_print!("Create a 5-by-3 matrix of random floats on the GPU", a);

Sample output

~/p/arrayfire_rust> cargo run --example helloworld
...
Create a 5-by-3 matrix of random floats on the GPU
[5 3 1 1]
    0.7402     0.4464     0.7762
    0.9210     0.6673     0.2948
    0.0390     0.1099     0.7140
    0.9690     0.4702     0.3585
    0.9251     0.5132     0.6814
...

Troubleshooting

If the build command fails with undefined references errors even after taking care of environment variables, we recommend doing a cargo clean and re-running cargo build or cargo test.

You can also use some environment variables mentioned in our book, such as AF_PRINT_ERRORS to print more elaborate error messages to console.

Acknowledgements

The ArrayFire library is written by developers at ArrayFire LLC with contributions from several individuals. The developers at ArrayFire LLC have received partial financial support from several grants and institutions. Those that wish to receive public acknowledgement are listed below:

Grants

This material is based upon work supported by the DARPA SBIR Program Office under Contract Numbers W31P4Q-14-C-0012 and W31P4Q-15-C-0008. Any opinions, findings and conclusions or recommendations expressed in this material are those of the author(s) and do not necessarily reflect the views of the DARPA SBIR Program Office.

You might also like...
rust wrapper for rocksdb

rust-rocksdb Requirements Clang and LLVM Contributing Feedback and pull requests welcome! If a particular feature of RocksDB is important to you, plea

UnQLite wrapper 1.0 is avaliable for Rust

unqlite A high-level UnQLite database engine wrapper. NOTE: Some of the documents is stolen from UnQLite Official Website. What is UnQLite? UnQLite is

libhdfs binding and wrapper APIs for Rust

hdfs-rs libhdfs binding library and rust APIs which safely wraps libhdfs binding APIs Current Status Alpha Status (Rust wrapping APIs can be changed)

A Rust wrapper and bindings of Allegro 5 game programming library

RustAllegro A thin Rust wrapper of Allegro 5. Game loop example extern crate allegro; extern crate allegro_font; use allegro::*; use allegro_font::*;

Safe OpenGL wrapper for the Rust language.

glium Note to current and future Glium users: Glium is no longer actively developed by its original author. That said, PRs are still welcome and maint

GLFW3 bindings and idiomatic wrapper for Rust.

glfw-rs GLFW bindings and wrapper for The Rust Programming Language. Example extern crate glfw; use glfw::{Action, Context, Key}; fn main() { le

Safe and rich Rust wrapper around the Vulkan API
Safe and rich Rust wrapper around the Vulkan API

Vulkano See also vulkano.rs. Vulkano is a Rust wrapper around the Vulkan graphics API. It follows the Rust philosophy, which is that as long as you do

Clear Coat is a Rust wrapper for the IUP GUI library.

Clear Coat Clear Coat is a Rust wrapper for the IUP GUI library. IUP uses native controls and has Windows and GTK backends. A macOS backend has been o

Idiomatic inotify wrapper for the Rust programming language

inotify-rs Idiomatic inotify wrapper for the Rust programming language. extern crate inotify; use std::env; use inotify::{ EventMask, Watch

An API Wrapper for https://paste.myst.rs written in rust
An API Wrapper for https://paste.myst.rs written in rust

PasteMyst.RS pastemyst-rs is an api wrapper for pastemyst written in Rust. ⚠ This package is under development ⚠ Sample usage To get a paste from past

Rust wrapper for the Fast Artificial Neural Network library

fann-rs Rust wrapper for the Fast Artificial Neural Network (FANN) library. This crate provides a safe interface to FANN on top of the low-level bindi

Rust wrapper for the BlingFire tokenization library

BlingFire in Rust blingfire is a thin Rust wrapper for the BlingFire tokenization library. Add the library to Cargo.toml to get started cargo add blin

dm-jitaux is a Rust-based JIT compiler using modified auxtools, dmasm and Inkwell LLVM wrapper for boosting Byond DM performance without any hassle!

dm-jitaux is a Rust-based JIT compiler using modified auxtools, dmasm and Inkwell LLVM wrapper for boosting Byond DM performance without any hassle (such as rewriting/refactroing your DM code).

duckdb-rs is an ergonomic wrapper for using duckdb from Rust.

duckdb-rs duckdb-rs is an ergonomic wrapper for using duckdb from Rust. It attempts to expose an interface similar to rusqlite. Acctually the initial

Rust wrapper for Eclipse iceoryx™ - true zero-copy inter-process-communication
Rust wrapper for Eclipse iceoryx™ - true zero-copy inter-process-communication

iceoryx-rs Experimental rust wrapper for the iceoryx IPC middleware. clone and build The iceoryx repo is include as git submodule, therefore keep in m

libnotcurses-sys is a low-level Rust wrapper for the notcurses C library

libnotcurses-sys is a low-level Rust wrapper for the notcurses C library This library is built with several layers of zero-overhead abstractions over

argmax is a library that allows Rust applications to avoid Argument list too long errors (E2BIG) by providing a std::process::Command wrapper with a

argmax argmax is a library that allows Rust applications to avoid Argument list too long errors (E2BIG) by providing a std::process::Command wrapper w

A rust wrapper for the spam protection API
A rust wrapper for the spam protection API

SpamProtection-rs Table of contents About Supported Rust version Features How to use Credits License About This repo has been shifted to the official

A Rust wrapper for the SponsorBlock API.

sponsor-block A Rust wrapper for the SponsorBlock API, which you can find complete documentation for here. Uses SponsorBlock data licensed under CC BY

Releases(v3.8.0)
  • v3.8.0(Jan 10, 2021)

    New Functions and Features

    • APIs - #244
      • max_ragged
      • cov_v2
      • var_v2, var_all_v2
      • stdev_v2, stdev_all_v2
    • Features
      • Serialization support for ArrayFire Types - #250

    Fixes

    • Fix return type trait bound on reduce all functions - #253

    Improvements in Upstream

    For information on improvements and bug fixes made in the upstream, ArrayFire, please refer to the following two release notes.

    Thank you!

    Source code(tar.gz)
    Source code(zip)
  • v3.7.2(Oct 6, 2020)

    v3.7.2

    This fix release fixes a critical bug regarding thread safety of structure wrappers of ArrayFire objects. This bug was inadvertently introduced in the v3.7.1 release. Hence, we are going to yank that version from crates.io. Existing users of v3.7.1 will still be able to use that crate version although multi-threaded code might not work as expected. We strongly recommend upgrading to v3.7.2 for all users.

    Improvements

    Apart from fixing the critical bug we have also added a new tutorial to our book with short code examples on how to use ArrayFire in multi-threaded programs

    Thank you! everyone.

    Source code(tar.gz)
    Source code(zip)
  • v3.7.1(Sep 9, 2020)

    v3.7.1

    Major Enhancements

    Improvements

    • Added IndexMut trait implementation for Dim4 structure - #230
    • Added support to let users create Array from raw device pointers - #234
    • Added example for Array::host method - #220
    • Added functions (missing FFI wrappers) to handle Pinned memory allocation and free functions - #238
    • Added bit shift trait implementations for Array by unsigned integer types - #236
    • Marked C FFI handle getter from Structures as unsafe - #234
    • Improved documentation of batch parameter for arithmetic functions - #234
    • Improved reorder_v2 function documentation - #218
    • Refactored AfError Enum to use fmt::Display instead of error::Error - #224
    • Refactored whole array reduce functions to use appropriate output type - #242
    • Updated indexing tutorials in md-book to include macro based examples - #239
    • Added new macros dim4 and seq to easily enable creation of Seq and Dim4 objects - #230
    • Fixed crate qualifier for functions used inside macro - #230

    Fixes

    • Fixed AfError Enum C representation to u32 for consistency - #234
    • Fixed axes computation in reorder_v2 function - #216
    • Fixed clippy warnings in data module tests - #218
    • Fixed documentation - #236 , #234 and #216
    • Fixed mutability of left-hand-size parameters of assignment operations(functions) - #224
    • Fixed pad FFI arguments in wrapper code - #247
    • Fixed set_row internal logic to handle unit vectors - #247
    • Fixed unused import warning in error handler test - commit

    Improvements in Upstream

    For information on improvements and bug fixes made in the upstream, ArrayFire, please refer to the following two release notes.

    Community Contributors

    Thank you! everyone.

    Source code(tar.gz)
    Source code(zip)
  • v3.7.0(Mar 14, 2020)

    New Features & Improvements

    New Features/Functions

    Fixes and Improvements

    • Linked to md-book on gh-pages so that docs.rs works
    • Fixed product functions output Array type. For boolean/char inputs, the output of product operation is char and everywhere else same as AggregateType alias.

    Improvements in Upstream

    • Added 16-bit floating point support for the following features/functions.
      • JIT
      • Printing of Array
      • Random Number Generation
      • Unary operators/functions
      • clamp
      • flat
      • matmul
      • reorder
      • select_scalar
      • transpose
    • Sparse array - Sparse array arithmetic support added in upstream.
    • Print stack trace on errors.

    For more information about the performance and bug fixes made in the upstream, ArrayFire, please refer to the following two release notes.

    Source code(tar.gz)
    Source code(zip)
  • v3.6.3(Jan 28, 2020)

    v3.6.3

    Updates

    • Fixed second argument of reorder API to be more clear - #203
    • Fixed unchecked string creation from ffi return value - #212
    • Implemented operator traits for Scalar and Array combinations - #208
    • Improved some tutorials - #204
    • Moved all tutorials into a mdbook - #204
    • Replaced deprecated uint8_t type with u8 - #209

    Community Contributors

    Thank you.

    Source code(tar.gz)
    Source code(zip)
  • v3.6.2(Jul 25, 2019)

    v3.6.2

    Updates

    • Added missing docs for FloatingPoint trait members (6fe03718e1872a7605e8d8af56e6d480a863c2c2)
    • Update num crate to 0.2 (d0ad33dba10f089c40fd14b76fa07901e08c04af)

    Community Contributors

    Thank you @maxtnuk and @acm0055 for reporting the issue with num crate version 0.2.

    Source code(tar.gz)
    Source code(zip)
  • v3.6.1(Jun 18, 2019)

    Improvements, Fixes and New Examples

    Improvements

    • Code changes to Rust 2018 Edition - #186
    • Reformatted code base using rustfmt tool - #186
    • Use self keyword where applicable instead of type names - #193 #194
    • Updated macros af_print, join_many and eval to work with expressions instead of identifiers - #195

    Bug Fixes

    • Added additional search path suffix (lib64) for dl-loading libs - #186
    • Fix comparison functions output type - #187
    • Internal traits are made public now to enable users write generic functions using arrayfire-rust's Array object - #188
    • Removed core from features - #190
    • Fixed documentation for nearest_neighbour & hamming_matcher - https://github.com/arrayfire/arrayfire-rust/commit/84446095cdf717599fa49ae878cb543930923d58
    • Corrected OSX DYLD path instruction in README - https://github.com/arrayfire/arrayfire-rust/commit/5d2ae2d3ec10296374bb33a78513b151a73d687b

    New Examples

    • Conway's Game of Life - #179
    • Simple & Basic Example of fft Usage - #196

    Community Contributors

    Thank you.

    For more information about the performance and bug fixes made in the upstream, ArrayFire, please refer to the following two release notes.

    Source code(tar.gz)
    Source code(zip)
  • v3.6.0(Sep 27, 2018)

    New Features & Improvements

    Functions

    Breaking Changes

    Prior to v3.6.0 Array structure was a non-generic structure that didn't carry any information about the type of data being managed by the ArrayFire's memory manager. From now on, Array is generic over the type of data it is storing, thus has all the benefits of Rust checks. This may result in few code changes on the user's side. Hopefully they are minimal. Please don't hesitate to contact if you face any issue while moving to 3.6.0. We have made the necessary modifications to the examples provided in the crate to give you an idea of what the changes might look like. We will keep improving the API based on community feedback.

    Improvements

    • Array is a generic and hence comes with all the checks rust carries out. Hopefully, this helps the users in avoiding type related issues.
    • All sub-modules are organized into domain based categories so that they can be compiled individually into a crate with only the required functionality. Core is the only mandatory module needed by any other module.

    Bug Fixes

    • Fix Rust enum representations to match FFI ABI.
    • Fix a couple of typos in the documentation.

    Community contributors

    Thank you.

    For more information about the performance and bug fixes made in the upstream, ArrayFire, please refer to the following two release notes.

    Source code(tar.gz)
    Source code(zip)
  • v3.5.0(Jun 28, 2017)

    New Features & Improvements

    Bug Fixes

    Breaking Changes

    New Features & Major Updates from ArrayFire Upstream

    • ArrayFire now supports threaded applications.
    • Sparse-Dense Arithmetic Operations.
    • Tuned OpenCL BLAS Backend.
    • Removed CUDA 6.5 Support
    • CUDA JIT now uses NVRTC instead of NVVM.
    • ArrayFire Graphics now use Forge v1.0 stable release.

    For a detailed information on improvements, bug-fixes, new-examples and known-issues, please go through the ArrayFire v3.5.0 release notes.

    Source code(tar.gz)
    Source code(zip)
  • v3.4.3(Apr 10, 2017)

    v3.4.3

    Fixes

    • Changed shift parameter type from unsigned type to signed type to enable usage of negative offsets. Shift was incorrectly using unsigned offset parameter earlier.
    • Fixed Rust String to CString conversion in image loading/saving functions.
    • Fixes/Changes in the documentation for following functions:
      • Array::copy and Clone trait implementation for Array
      • Add note to std::ops traits implementation explicitly stating they carry out element wise operations.
      • Corrected documentation dot that it accepts only vector/scalar arrays.
    • Added more search locations for build.rs script to look for ArrayFire libraries.
    Source code(tar.gz)
    Source code(zip)
  • v3.4.2(Feb 26, 2017)

    v3.4.2

    Features

    • info_string - Returns the library meta-information as std::string::String.
    • Added arithmetic(+, -, *, /, %, &, |, ^, <<, >>) traits implementations for all input combinations of Array and &Array types.
    • Added a batch(boolean) parameter for logical operation functions - this breaks the API and please change your code where you call these functions accordingly. We are sorry for the inconvenience caused.
    • get_revision - Returns ArrayFire Revision (commit) information of the library as a string.
    • device_info - Returns a quadruple of Strings indicating the name, platform, toolkit name and computer version of the currently active device.

    Fixes

    Community contributors for this release

    Thank you.

    Source code(tar.gz)
    Source code(zip)
  • v3.4.1(Jan 11, 2017)

    v3.4.1

    Features

    • Neg trait implementation for object type Array
    • New set of following functions that lets the user create an array based on dimensions and a particular DType. Earlier to this addition, data generation functions deduced the target array type using generic type.
      • constant_t
      • range_t
      • iota_t
      • identity_t

    Examples

    • A new graphics example that illustrates acoustic wave propagation.

    Fixes

    Community contributors for this release

    Thank you.

    Source code(tar.gz)
    Source code(zip)
  • v3.4.0(Sep 15, 2016)

    Features

    • Sparse Matrix and BLAS
      • Support for CSR and COO storage types.
      • Sparse-Dense Matrix Multiplication and Matrix-Vector Multiplication as a part of af::matmul() using CSR format for sparse.
      • Conversion to and from dense matrix to CSR and COO storage types.
    • Faster JIT
      • Performance improvements for CUDA and OpenCL JIT functions.
      • Support for evaluating multiple outputs in a single kernel. See eval!() macro or function eval_multiple().
    • Random Number Generation
      • A random engine object to handle setting the random engine type and seed for random number generator engines.
      • Supported engine types are:
    • Graphics
      • Using Forge v0.9.0
      • New Functions to render Vector Fields
        • Window::draw_vector_field2()
        • Window::draw_vector_field3()
        • Window::draw_vector_field()
      • Multiple overlays on the same window are now possible.
        • Overlays support for same type of object (2D/3D)
        • Supported by Window::draw_plot[2|3](), Window::draw_hist(), Window::draw_surface(), Window::draw_vector_field[2|3]().
      • New API to set axes limits for graphs.
        • Draw calls do not automatically compute the limits. This is now under user control.
        • Window::set_axes_limits_[2d|3d|compute]() can be used to set axes limits automatically or manually.
        • Window::set_axes_titles() can be used to set axes titles.
      • New API for plot and scatter:
        • Window::draw_plot() and Window::draw_scatter() now can handle 2D and 3D and determine appropriate order.
        • draw_plot()
        • draw_plot2()
        • draw_plot3()
        • draw_scatter()
        • draw_scatter2()
        • draw_scatter3()
    • New interpolation types to enum InteropType that apply to following functions
      • resize()
      • transform()
      • approx1()
      • approx2()
    • Support for complex mathematical functions
      • Add complex support for trignometry functions, sqrt(), log().
    • medfilt1(): Median filter for 1-d signals
    • Generalized scan functions: scan_func_scan and scan_func_scanbykey
      • Now supports inclusive or exclusive scans
      • Supports binary operations defined by BinaryOp.
    • Image Moments functions
    • Add get_size_of() function for dtype

    For other information regarding bug fixes, compile time improvements and known issues in ArrayFire upstream, please visit the ArrayFire v3.4.0 Release Notes URL.

    Broken/Replaced API

    • The behaviour of Window::draw_plot has been to changed to handle generic plot rendering, 2D or 3D line plots. New functions Window::draw_plot[2|3] are added for dimension specific plot rendering.
    • The behaviour of Window::draw_scatter has been to changed to handle generic plot rendering, 2D or 3D line plots. New functions Window::draw_scatter[2|3] are added for dimension specific plot rendering.
    Source code(tar.gz)
    Source code(zip)
  • v3.3.1(Jun 8, 2016)

    v3.3.1

    Fixes

    • Program crashes on release builds reported here has been fixed.
    • Dependent crates(libc, num, rustc-serialize) versions have been bumped up.

    Community contributors for this release

    Thank you.

    Source code(tar.gz)
    Source code(zip)
  • v3.3.0(May 20, 2016)

    Major Updates

    • API breaking change is that error handling mechanism of returning Result objects from functions has been replaced with a callback style error handling. By default, we provide an error handler that panics with an appropriate message when a given function call or operation fails. If the users chooses to, they can also implement the error handler by themselves and call register_error_handler that lets the user set the function that has to handle the error values returned by ArrayFire FFI calls.
    • enum Aftype has been refactored to DType
    • CPU backend supports aysnchronous execution.
    • Performance improvements to OpenCL BLAS and FFT functions.
    • Improved performance of memory manager.
    • Improvements to visualization functions.
    • Improved sorted order for OpenCL devices.

    New Functions and Features:

    • Scatter plot added to graphics functionality
    • New function get_active_backend that gives us the current active backend.
    • Improved Array Creation/Generation API
    • Added mem_info macro to print GPU memory usage information to standard output.
    • Added af_print macro.
    • Added traits clone and partialeq to all enums.
    • Added traits partialeq and debug to type Dim4.
    • transform() now supports perspective transformation matrices.
    • Type Array now has the implementations for the compound assignment operations traits. These traits are auto-enabled only if you are using Rust >= 1.8.0 since those traits are stabilized from that particular version.
    • A few new member functions are added to object Array.
    • Following are the other miscellaneous functions added to the library
      • is_lapack_available - Returns true if ArrayFire was compiled with LAPACK functions enabled
      • is_imageio_available - Returns true if ArrayFire was compiled with Freeimage enabled
      • New member function for Array Object, get_device_id, that gets the device id on which the array resides.

    Following are the community contributors for this release.

    Thank you guys!

    Source code(tar.gz)
    Source code(zip)
  • v3.2.0(Dec 10, 2015)

    • Feature parity with ArrayFire 3.2 libs except any CUDA/OpenCL pinned memory related functions.

    The wrapper has known issue with ArrayFire v3.2.0 libs due to a single missing symbol af_draw_surface from the native library. Please use ArrayFire v3.2.1 fix release to fix the problem. Any version > 3.2.1 should also work fine.

    Source code(tar.gz)
    Source code(zip)
Owner
ArrayFire
ArrayFire
BLAS bindings for Rust

RBLAS Rust bindings and wrappers for BLAS (Basic Linear Algebra Subprograms). Overview RBLAS wraps each external call in a trait with the same name (b

Michael Yang 77 Oct 8, 2022
gmp bindings for rust

Documentation The following functions are intentionally left out of the bindings: gmp_randinit (not thread-safe, obsolete) mpz_random (not thread-safe

Bartłomiej Kamiński 37 Nov 5, 2022
Scientific Computing Library in Rust

SciRust Scientific computing library written in Rust programming language. The objective is to design a generic library which can be used as a backbon

In Digits 242 Dec 16, 2022
Statistical computation library for Rust

statrs Current Version: v0.13.0 Should work for both nightly and stable Rust. NOTE: While I will try to maintain backwards compatibility as much as po

Michael Ma 384 Dec 27, 2022
Collection of Optimization algorithm in Rust

rustimization A rust optimization library which includes L-BFGS-B and Conjugate Gradient algorithm. Documentation The simplest way to use these optimi

Naushad Karim 47 Sep 23, 2022
The write-once-run-anywhere GPGPU library for Rust

The old version of Emu (which used macros) is here. Overview Emu is a GPGPU library for Rust with a focus on portability, modularity, and performance.

Caleb Winston 1.5k Dec 30, 2022
Easy c̵̰͠r̵̛̠ö̴̪s̶̩̒s̵̭̀-t̶̲͝h̶̯̚r̵̺͐e̷̖̽ḁ̴̍d̶̖̔ ȓ̵͙ė̶͎ḟ̴͙e̸̖͛r̶̖͗ë̶̱́ṉ̵̒ĉ̷̥e̷͚̍ s̷̹͌h̷̲̉a̵̭͋r̷̫̊ḭ̵̊n̷̬͂g̵̦̃ f̶̻̊ơ̵̜ṟ̸̈́ R̵̞̋ù̵̺s̷̖̅ţ̸͗!̸̼͋

Rust S̵̓i̸̓n̵̉ I̴n̴f̶e̸r̵n̷a̴l mutability! Howdy, friendly Rust developer! Ever had a value get m̵̯̅ð̶͊v̴̮̾ê̴̼͘d away right under your nose just when

null 294 Dec 23, 2022
Zero-cost high-level lua 5.3 wrapper for Rust

td_rlua This library is a high-level binding for Lua 5.3. You don't have access to the Lua stack, all you can do is read/write variables (including ca

null 47 May 4, 2022
Objective-C Runtime bindings and wrapper for Rust.

Objective-C Runtime bindings and wrapper for Rust. Documentation: http://ssheldon.github.io/rust-objc/objc/ Crate: https://crates.io/crates/objc Messa

Steven Sheldon 336 Jan 2, 2023
A low-level ncurses wrapper for Rust

ncurses-rs This is a very thin wrapper around the ncurses TUI lib. NOTE: The ncurses lib is terribly unsafe and ncurses-rs is only the lightest wrappe

Jeaye Wilkerson 628 Jan 7, 2023