Discover lambdaclass/aleo_minimum_anti_collusion

cairo-vm is a Rust implementation of the Cairo VM. Cairo (CPU Algebraic Intermediate Representation) is a programming language for writing provable programs, where one party can prove to another that a certain computation was executed correctly without the need for this party to re-execute the same program.

607

cairo-vm

LambdaClass Hobby Club, hacking learning path handbook. The journey starts here!

514

lambdaclass_hacking_learning_path

224

starknet_in_rust

A Rust implementation of Starknet execution logic

Small exercises to get you used to reading and writing Erlang code

171

erlings

Simple backtesting software for options

164

options_backtester

Patricia Merkle Tree implementation in Rust

159

merkle_patricia_tree

An up to date riak_core tutorial, using basho's riak_core, Erlang/OTP 23-24-25 and rebar3.

154

riak_core_tutorial

STARK 101 Workshop in Rust 🐺🦀

149

STARK101-rs

Public repository for excersices, challenges and all the needs of the Sparkling Water Bootcamp

131

sparkling_water_bootcamp

123

concrete

Concrete is a simple programming language specifically crafted for creating highly scalable systems that are reliable, efficient, and easy to maintain.

A compiler to convert Cairo's intermediate representation "Sierra" code to MLIR.

123

cairo_native

Lambda Ethereum Rust Execution client

115

ethereum_rust

Elixir implementation of an Ethereum consensus client, which offers high reliance & fault tolerance

113

lambda_ethereum_consensus

Juypter notebooks playground to explore and analyse economy and finance ideas

finance_playground

Signaling and ICE servers for WebRTC in Erlang

webrtc-server

STARK Cairo prover using lambdaworks. Cairo (CPU Algebraic Intermediate Representation) is a programming language for writing provable programs, where one party can prove to another that a certain computation was executed correctly. Cairo and similar proof systems can be used to provide scalability to blockchains.

lambdaworks_stark_platinum

mina_bridge

Bridge from Mina to Ethereum

Solidity

evm_mlir

An EVM written with MLIR

AES_zero_knowledge_proof_circuit

Erlang + ClojureScript app to send holiday reminders

holiday_pinger

Stark Compass: the only open source explorer

stark_compass_explorer

Multiplayer 2D physics engine, matchmaking, market and leaderboard for 2D and 3D Games

mirra_backend

👌 erlang grab bag of useful functions. it should have been called swiss army knife but katanas are more deadlier ;)

erlang-katana

cairo-vm_in_go is a Go implementation of the Cairo VM. Cairo (CPU Algebraic Intermediate Representation) is a programming language for writing provable programs, where one party can prove to another that a certain computation was executed correctly without the need for this party to re-execute the same program.

cairo-vm_in_go

libtorrent-rs

A Rust implementation of the BitTorrent V2 protocol

YAS is Yet Another Swap on Starknet but bringing the best prices and yield to Degens.

yet-another-swap

Cairo

starknet_tendermint_sequencer

Starknet sequencer built with Tendermint Core

Yul precompile library to speedup elliptic curves operations.

zksync_era_precompiles

Champions of Mirra game codebase

champions_of_mirra

circom_export_to_cairo

Export Circom verifier to Cairo

Solidity

starknet_stack

Starknet Stack let's you easily create new Cairo Starknet chains with their own sequencers, provers and verifiers

Erlang/OTP application to rate limit resource access

throttle

Zero Knowledge Virtual Machine from scratch implementing Pinocchio

cairo-by-example

cairo-by-example.com

Shell

pinocchio_lambda_vm

A conference by devs for devs. Functional Programming, Distributed Systems, Big Data and Machine Learning Conference in Buenos Aires, Argentina

buzzconf

HTML

zksync-web3-rs

Small exercises to get you used to reading and writing Julia code!

julia_koans

Julia

noir_backend_using_gnark

A Noir's backend implementation using Gnark

cairo-vm-py

cairo-rs-py adds Python bindings to the cairo-rs Cairo VM

An ABI compatible for KZG EIP-4844 in Rust

lambdaworks_kzg

Arkworks implementation of the VM of Aleo verifiable computing model built by LambdaClass

aleo_lambda_vm

Arkworks made simple for us: the non cryptographer software plumbers

simpleworks

era_vm

EraVM implementation

cairo-vm_in_C is a C implementation of the Cairo VM. Cairo (CPU Algebraic Intermediate Representation) is a programming language for writing provable programs, where one party can prove to another that a certain computation was executed correctly without the need for this party to re-execute the same program.

cairo-vm.c

C++

programming_bitcoin_in_rust

Implementing the book "Programming Bitcoin" in Rust

Anonymity Research Tools for TCash Users

tornado_cash_anonymity_tool

Tendermint implementation of the blockchain of Aleo verifiable computing model built by LambdaClass

aleo_lambda_blockchain

Contains several examples and challenges to use Lambdaworks

starknet_prover

lambdaworks_exercises

An implementation of the Austral language compiler in Rust

austral.rs

Soverign rollup based on Rollkit, Cairo VM for the application layer and Bitcoin as a DA layer

starknet_rollup_on_bitcoin

Ethereum Consensus Client

lambda_consensus

starknet_kraken

Kraken is a Starknet modular decentralized sequencer implementation.

LambdaClass statistics, machine learning and data science etudes

cairo_karnak

Cairo bytecode compiler

data_etudes

We were tired of implementing a reconnection system for our database clients so we created this

reconnections

Find other erlang peers in the same subnet

find_peers

Simple wordpress replacement coded in Elixir + Phoenix + Ecto + PostgreSQL + Docker

PLONK101-rs

elephant_in_the_room

CSS

zksync_local_stack

Makefile

game_of_life_wasm

Conway's Game of Life in Rust and WebAssembly

Wrapper to Riak Core for Elixir

elixir_riak_core

A Rust library providing a builder API to generate Cairo code

cairo_codegen-rs

zkRust

Low level (VHDL) hardware description for MSM acceleration over FPGA

lambda_msm_fpga

Open source game assets: 3D models, 2d concept art, lore, music and more!

curse_of_mirra_assets

pinpon

🏓 lambdaclass ping pong tournament and player ranking

Course material for students who want to go from zero to participating in the IEEExtreme competence using Python

ieeextreme

Entropy1729's Learning path

entropy_hacking_learning_path

metal_playground

A repo for learning how to parallelize computations in the GPU using Apple's Metal, in Rust.

aleo_roulette

Send lager logs to logstash

cairo_finance

Cairo finance utilities

Cairo

lager_logstash_backend

lambdaworks_plonk_prover

bonobot

accept the mystery

Add this to your release to get standard erlang metrics in prometheus/grafana

beam_prometheus_exporter

Trying to achieve a few millions requests per second with different languages, libraries and protocol

million_requests_per_second

Ruby

mithril-oxide

Bindings to MLIR using the full C++ API

A collection of fuzzers built using Honggfuzz and Cargofuzz tools

fuzzing_examples

data_science_exercise

Data science exercise

Blockade docker API wrapper written in Erlang

blockaderl

We are slow while using the UI/UX of crypto wallets so we created our CLI version

starknet_orb

ethereum_war_game_tooling

CLI tool for ZKsync, built using zksync-ethers-rs SDK

zk_stack_cli

Redirect Erlang shell output to kibana via logstash

erlang_log_to_kibana_example

Shell

cairo-rs-wasm

Provides a way of reading a real Starknet State, so you can re-execute an existing transaction in any of the Starknet networks in an easy way

starknet-replay

aggregation_aligned_layer

Design and coding standards for LambdaClass

guidelines

tendermint_consensus

Tendermint Consensus is a minimalistic implementation of the BFT consensus algorithm to securely replicate state machines on multiple machines.

go-http-ipfs

HTTP server in Go to interact with a local IPFS node

cairo_wnn

Cairo Weightless Neural Network

chaos_monkey_ex

A Chaos Monkey for Elixir that kills random processes

A differential fuzzer for `concrete-ml` and `scikit-learn`

wasm2cairo

merkletree_leo

concrete-ml-fuzzer

Proof of concept Rust implementations for various distributed systems protocols

consensus-workbench

A Farcaster client implementation in Elixir

lambcast