Lib.rs

halo2curves

Elliptic curve implementations and wrappers for halo2 library

binding_macros

Macros to build customized bindings interface

probe

Static instrumentation probes

aws-sdk-geoplaces

AWS SDK for Amazon Location Service Places V2

kzg-rs

KZG point evaluation

laz

Rust port of Laszip compression. of the LAS format

backgammon

The Rust Backgammon library

vvdec

Rust bindings for VVdeC

liblrs

manipulate linear referencing systems

stroke

Zero-allocation, const-generic implementations of Bézier and B-Spline curves in N-dimensional euclidean space

grid_pathfinding

Pathfinding using jump point search (JPS) and connected components on a 2D grid

roguemetry

Geometry utils for 2D tile-based games

vtk-rs

Rust bindings for the Visualization Toolkit (VTK)

roaring-landmask

A fast and limited-memory structure with a landmask based on GSHHG for determing whether a point on Earth is on land or in the ocean

poulpy-hal

providing layouts and a trait-based hardware acceleration layer with open extension points, matching the API and types of spqlios-arithmetic

mutils

Mathematical-like utilities. Points, Sizes, Colours, maths operating on them. Things like that.

sphere-n-rs

N-Sphere Code Generation in Rust

ndimpoint

working with N-dimensional points in Rust

pasture-core

A framework for working with point cloud data

elements-lang

A geometry markup language and diagram renderer

conformal_vst_wrapper

Implements a VST3-compatible plug-in for audio processors implemented with the conformal audio plug-in framework

binary-search

Generic binary search implementation

healpix

tesselation

sigma-compiler

automatically generating code for sigma zero-knowledge proof protocols of more complex statements than are supported by the sigma-proofs crate. The statements given to this crate are…

coursepointer

Converts waypoints into Garmin FIT course points

probabilistic_bisector

bisection for one-dimensional functions in the presence of noise

async-local

For using thread locals within an async context across await points

recuerdame

Pre-calculate functions at compile-time rather than run-time

tuirealm-orx-tree

Tree Component for TUIRealm with orx-tree

vector-editor-core

Core structures for editing point based structures

grid_search_cardinal_distance_map

Grid where each cell stores the distance from a set of interesting points to each cell in a uniform-cost cardinal grid

percentum

Percentage type sanity

r2x-python

Python bridge for the r2x CLI

servicepoint2

CCCB Service Point Display

geo-geodesy

Geodesy integration with the geo crate

slosh3d

Cross-platform GPU 3D Material Point Method implementation

slosh2d

Cross-platform GPU 2D Material Point Method implementation

warp-directory

command line tool to quickly change directories

pts

GUI to create, manipulate, and arrange points on a canvas

brouter-client

API Client implement for brouter

progscrape

progscrape.com web application

contourable

differentiable functions

dsp-fixedpoint

Fixed point types for DSP

wasm_split_cli_support

Split a WASM module into lazily loadable chunks

arrowdb

高性能本地向量数据库

python-mod

A macro library for including a Python module in Rust. At this point, very imcomplete.

kprobe

implementing kernel probes (kprobes) in operating systems

pi_polygon

polygon

treedee

3D rasterizer

opencloudmesh

protocol

nsys-math-utils

Math types and traits

hedgehog-rs

interacting with the Posthog API

density-mesh-core

Core module for density mesh generator

ferrite-navigation

Navigation and path handling for Ferrite image viewer

point-nd

flexible no-std struct to model points on axes of any dimensions

int-vec-2d

Vectors, points, rectangles, etc. with i16 coordinates.

hilbert

curve transform and inverse for points having two to thousands of dimensions, using Skilling's algorithm

codemap-cli

A CLI for understanding and onboarding to codebases

geomath

Stack-allocated maths for geometry, simulation and computer graphics

rene

Computational geometry

image-moments

Efficient and compile-time checked calculations of contour moments

rythonc

A command-line Python to Rust compiler, at this point, very incomplete

fenrix

Main entry point for Fenrix: A modern Rust UI framework for building fast, reliable, and beautiful web apps

quad-to-quad-transformer

Translate 2d points from one quad to another

r3fit

RANSAC algorithm that uses 3 samples to estimate a circle over the given points

scad

generating OpenSCAD models using rust

snapers

btrfs snapshot creator

shuriken-bindings

Safe bindings for the [Shuriken bytecode analyzer

t-spline-commands

operations to perform on t-spline data structures

rendezvous

Easier rendezvous channels for thread synchronization

cube-rotations

Models the rotations that can happen on a cube without changing the set of planes to which its faces are parallel

siapla

agile planning tool

minvect

A mini vector library

tokio-postgres-openssl

TLS support for tokio-postgres via openssl

tiff-encoder

creating TIFF files

grid_util

primitive constructs like Grid, Point, Rect, etc

cargo-incremental

using and testing rustc's incremental compilation support

gc-sequence

a system for encoding safe points for computations running on gc-arena

dbscan

Dependency free implementation of DBSCAN clustering

boostvoronoi_ext

Boost voronoi private workspace (this workspace will be re-integrated in the main crate in next release)

otarustlings

otafablab rustlings

color-core

Color shared definition

cairo-lang-compiler

Cairo compiler

spaceindex

sp-arithmetic

Minimal fixed point arithmetic primitives and types for runtime

lachesis

GPS stop point detection from Hariharan and Toyama (2004) 'Project Lachesis: Parsing and Modeling Location Histories'

tokio-interruptible-future

Easily interrupt async code in given check points. It's useful to interrupt threads/fibers.

wena

micro-framework that provides an elegant starting point for your console application

waker-waiter

async runtimes interoperate with arbitrary futures

vcddiff

that can compare two VCD files and point to sources of divergence

boost_context

Boost C++ library boost_context packaged using Zanbil

sel4-start

defining the entry point to the initial thread on seL4

bresenham

A fast, iterator-based integer-only implementation of Bresenham's line algorithm

caliph

calibrate and convert pH measurements using a two point method

advancedresearch-higher_order_point

An experimental higher order data structure for 3D points

differential-geometry

differential-geometric calculations

rust_line_rasterizer

line rasterization

orthogonal-rotation

Functions for rotating the points on a square

guessture

$1 unistroke recognizer algorithm in Rust

interiors

Primal-Dual Interior Point Method for Nonlinear Programming

vector-store-flows

Vector store integration for flows.network

iter-tee

Make several clones of an iterator

cutoff_list

A linked-list structure where each element tracks how many predefined "cutoff points" precede or coincide with its position in the list sequence

selfe-start

defining the entry point to the initial thread on seL4

influxdb-client

Rust client library for InfluxDB v2

rust_bresenham

determining Bresenham lines

multi_dim_point

multi-dimensional point

mandelbrot-orbits-rust

A console command to generate an image of the Mandelbrot Set where each pixel color represents the period of the complex point (if the point belongs to the Set)

shape-svg

SVG representation of shapes

ponsic-types

The dependency of the ponsic crate

leaf-spread

iterate indefinitely over well spread points, similar to some leaf arrangement pattern in nature

globe-rs

management of geographic coordinates

fixed-point

Fixed point numbers

kabsch_umeyama

Kabsch-Umeyama algorithm is a method for aligning and comparing the similarity between two sets of points. It finds the optimal translation, rotation and scaling by minimizing the root-mean-square deviation (RMSD)…

wasm_split_macros

Split a WASM module into lazily loadable chunks

bicubic

A base for bicubic interpolation

polynomials_pro

pro-level polynomials

homography

estimation using point and line correspondences

casper-contract-schema

Data structures for the Casper Contract Schema

simplify

simplify-js port to rust

zero_point_nine

A CLI which allows you to send HTTP/0.9 requests

roxy-proxy

High-performance Ethereum JSON-RPC proxy

magnus-macros

Derive and proc macros for magnus

supercluster-rs

Supercluster for fast hierarchical point clustering

higher_order_point

An experimental higher order data structure for 3D points

global_value_manager

A global value manager

agb_macros

Macro for declaring the entry point for a game using the agb library

intersection_detection

Compute intersections between 2D lines

point_reader

CLI tool to read and display VSE points data

geom2d

useful for manipulation of various of types including: numerals, points, vectors, etc... and includes various methods for flexibility.

pezsp-arithmetic

Minimal fixed point arithmetic primitives and types for runtime

gamozolabs/pe_parser

Pure Rust x86_64 bootloader and kernel

laptimer

print the time spent between different points in a program

scaled

euclid point and vector types with fixed-point scalars

stackpin

data that should be pinned to the stack at the point of declaration

siiir_points

Data structures representing points in 2D & 3D space

boostvoronoi_core

Boost voronoi private workspace (this workspace will be re-integrated in the main crate in next release)

fedimint-tpe

tpe is a helper cryptography library for threshold point encryption

solana-secp256k1

Efficient, SVM-friendly implementations of common Secp256k1 functions

splinosaurus

flexible spline and surface library

foundry-mpc-rs

shamir-secret-sharing implementation forked from Lúcás C. Meier's cait_sith protocol and ZcashFoundation's frost

makepad-geometry

Geometry tools

alphalpha

The alpha and weak-alpha filtrations of a set of points in the plane

min32

Minimal boilerplate code for targeting win32 with no-std

haversiner

Find the Haversine distance between two points

CLAAR

Command Line As A Renderer is a simple library that lets you turn the console into a screen for drawing triangles and points and what-not. An example of how to use the library can be found in main.rs.

global-duration

Enables simple measurement of durations between arbitrary points in Rust code

rust_geometry

A geometry library for problems in ICPC programming contests

pasture-derive

Macro implementations for #[derive(PointType)]

cosiest_noisiest

allows generating 1d noise at arbitrary points

embassy-executor-macros

macros for creating the entry point and tasks for embassy-executor

points_between

API to list the evenly-spaced discrete points between two N-dimensional points

tg4-engagement

TG4 implementation of group membership controlled by an admin

ode

Various solvers for ODEs

antipode

Compute the antipode of a geographic point

libecdsautil

Safe bindings to libecdsautil for ec25519 signing

grid-point

A Point represents an [x, y] coordinate on a grid or matrix

wasm-grate

Analyzes JS projects for potential WebAssembly migration points

atlas-bls-signatures

Atlas BLS Signatures

polyline_rust

encode/decode polylines in "Encoded Polyline Algorithm Format"

solana-bls-signatures

Solana BLS Signatures

pagan

Data analysis library

arcium-core-utils

Arcium core utils

smol-graph

to-the-point Rust graph implementation

iwls

Shows available Wi-Fi access points and suggests the best channel to use

anchored

things can't cross the .await point

cubic-splines

fitting cubic splines to datasets

kdt

k-dimensional tree implemented with const generics

simplicity

simulation of simplicity (https://arxiv.org/pdf/math/9410209.pdf)

tg3

Tgrade-3 Interface: On-Chain MultiSig/Voting contracts

tg4-stake

TG4 implementation of group based on staked tokens

trk

terminal-based time-series data recorder and plotter

wasi-binio-wasm

Allow complex data structure to be transffered as function arguments and results between host and wasm

point_like

Traits for 2D point-like types

bbox3d-estimator

can estimate a 3D bounding box given a set of 3D points by Rotating Caliper algorithm