Explore @lambdaclass Open Source projects

Top Rating
- Top Contributors
  Discover the Top Open Source contributors by country or by language
- Interviews
  Discover real stories from Open Source developers
Discover

Discover your Favorite Language
Discover the top trending repositories and projects on Github. Explore the latest trends in your preferred languages.

Emacs Lisp

Jupyter Notebook

C++

Zig

Clojure

JavaScript

Lua

Go

More Languages
Awesome

Awesome repositories
Discover the most awesome repositories and projects of your favorite languages. Inspired by the Awesome-* lists trend in GitHub.

Erlang

PowerShell

Ada

Ruby

Rust

R

Groovy

F#

More Languages
By Country

Rankings by Country
Discover the community of talented open source contributors in each country.

🇲🇰 North Macedonia

🇫🇯 Fiji

🇰🇪 Kenya

🇬🇼 Guinea-Bissau

🇹🇷 Türkiye

🇨🇳 China

🇭🇹 Haiti

🇵🇦 Panama

All Countries Compare Countries

Lambdaclass (@lambdaclass)

lambdaclass

Stars
4,598
Global Org. Rank 4,961 (Top 2 %)
Registered almost 11 years ago
Most used languages

Rust
38.9 %

Elixir
10.6 %

Erlang
9.7 %

Jupyter Notebook
7.1 %

Python
4.4 %

Julia
3.5 %

Go
2.7 %

C++
2.7 %

Solidity
2.7 %

Shell
2.7 %

HCL 1.8 %

C#
1.8 %

HTML
1.8 %

Makefile 1.8 %

Cairo 1.8 %

TypeScript
1.8 %

Others 4.5 %
Location 🇦🇷 Argentina
Country Total Rank 20
Country Ranking

Cairo 1

Erlang
1

Rust
1

Elixir
2

Solidity
3

TLA 3

Julia
4

Jupyter Notebook
4

Nix
9

Jinja 12

Makefile 13

Go
15

C#
32

HCL 37

Shell
46

HTML
47

C++
77

CSS
102

Ruby
142

Python
220

TypeScript
680

lambdaworks

lambdaworks offers implementations for both SNARKs and STARKs provers, along with the flexibility to leverage their individual components for constructing customized SNARKs.

cairo-vm

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.

lambdaclass_hacking_learning_path

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

starknet_in_rust

A Rust implementation of Starknet execution logic

erlings

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

options_backtester

Simple backtesting software for options

Jupyter Notebook

merkle_patricia_tree

Patricia Merkle Tree implementation in Rust

riak_core_tutorial

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

STARK101-rs

STARK 101 Workshop in Rust 🐺🦀

Jupyter Notebook

sparkling_water_bootcamp

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

concrete

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

cairo_native

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

ethereum_rust

Lambda Ethereum Rust Execution client

lambda_ethereum_consensus

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

finance_playground

Juypter notebooks playground to explore and analyse economy and finance ideas

Jupyter Notebook

webrtc-server

Signaling and ICE servers for WebRTC in Erlang

lambdaworks_stark_platinum

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.

mina_bridge

Bridge from Mina to Ethereum

evm_mlir

An EVM written with MLIR

AES_zero_knowledge_proof_circuit

holiday_pinger

Erlang + ClojureScript app to send holiday reminders

stark_compass_explorer

Stark Compass: the only open source explorer

mirra_backend

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

erlang-katana

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

cairo-vm_in_go

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.

libtorrent-rs

A Rust implementation of the BitTorrent V2 protocol

yet-another-swap

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

starknet_tendermint_sequencer

Starknet sequencer built with Tendermint Core

zksync_era_precompiles

Yul precompile library to speedup elliptic curves operations.

champions_of_mirra

Champions of Mirra game codebase

circom_export_to_cairo

Export Circom verifier to Cairo

starknet_stack

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

throttle

Erlang/OTP application to rate limit resource access

cairo-by-example

cairo-by-example.com

pinocchio_lambda_vm

Zero Knowledge Virtual Machine from scratch implementing Pinocchio

buzzconf

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

zksync-web3-rs

julia_koans

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

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

lambdaworks_kzg

An ABI compatible for KZG EIP-4844 in Rust

aleo_lambda_vm

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

simpleworks

Arkworks made simple for us: the non cryptographer software plumbers

era_vm

EraVM implementation

cairo-vm.c

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.

programming_bitcoin_in_rust

Implementing the book "Programming Bitcoin" in Rust

tornado_cash_anonymity_tool

Anonymity Research Tools for TCash Users

Jupyter Notebook

aleo_lambda_blockchain

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

starknet_prover

lambdaworks_exercises

Contains several examples and challenges to use Lambdaworks

austral.rs

An implementation of the Austral language compiler in Rust

aleo_minimum_anti_collusion_infrastructure

Aleo's Minimum Anti-Collusion Infrastructure / MACI

starknet_rollup_on_bitcoin

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

lambda_consensus

Ethereum Consensus Client

starknet_kraken

Kraken is a Starknet modular decentralized sequencer implementation.

cairo_karnak

Cairo bytecode compiler

data_etudes

LambdaClass statistics, machine learning and data science etudes

Jupyter Notebook

reconnections

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

find_peers

Find other erlang peers in the same subnet

PLONK101-rs

elephant_in_the_room

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

zksync_local_stack

game_of_life_wasm

Conway's Game of Life in Rust and WebAssembly

elixir_riak_core

Wrapper to Riak Core for Elixir

cairo_codegen-rs

A Rust library providing a builder API to generate Cairo code

zkRust

lambda_msm_fpga

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

curse_of_mirra_assets

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

pinpon

🏓 lambdaclass ping pong tournament and player ranking

ieeextreme

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

Jupyter Notebook

entropy_hacking_learning_path

Entropy1729's Learning path

metal_playground

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

aleo_roulette

cairo_finance

Cairo finance utilities

lager_logstash_backend

Send lager logs to logstash

lambdaworks_plonk_prover

bonobot

accept the mystery

beam_prometheus_exporter

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

million_requests_per_second

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

mithril-oxide

Bindings to MLIR using the full C++ API

fuzzing_examples

A collection of fuzzers built using Honggfuzz and Cargofuzz tools

data_science_exercise

Data science exercise

Jupyter Notebook

blockaderl

Blockade docker API wrapper written in Erlang

starknet_orb

ethereum_war_game_tooling

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

zk_stack_cli

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

erlang_log_to_kibana_example

Redirect Erlang shell output to kibana via logstash

cairo-rs-wasm

starknet-replay

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

aggregation_aligned_layer

guidelines

Design and coding standards for LambdaClass

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

wasm2cairo

merkletree_leo

concrete-ml-fuzzer

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

consensus-workbench

Proof of concept Rust implementations for various distributed systems protocols

lambcast

A Farcaster client implementation in Elixir