repos
93
ecosystems
11
languages
20
commits
4,056
─── top repos · by commits
─── repositories
93 totalcairo-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.
Cleopatra Cairo is a Rust implementation of the Cairo VM. Cairo 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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
cairo-rs 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. Cairo and similar proof systems can be used to provide scalability to blockchains.
Backtester for evaluating options and equity portfolio strategies over historical data. Includes tools for strategy sweeps, tail-risk hedge analysis, and signal-based timing research.
Concrete is a simple programming language specifically crafted for creating highly scalable systems that are reliable, efficient, and easy to maintain.
Juypter notebooks playground to explore and analyse economy and finance ideas
lambdaworks offers implementations for both SNARKs and STARKs provers, along with the flexibility to leverage their individual components for constructing customized SNARKs.
LambdaClass Hobby Club, hacking learning path handbook. The journey starts here!
lambdaworks offers implementations for both SNARKs and STARKs provers, along with the flexibility to leverage their individual components for constructing customized SNARKs.
A conference by devs for devs. Functional Programming, Distributed Systems, Big Data and Machine Learning Conference in Buenos Aires, Argentina
Small exercises to get you used to reading and writing Erlang code
LambdaClass statistics, machine learning and data science etudes
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.
Entropy1729's Learning path
We are slow while using the UI/UX of crypto wallets so we created our CLI version
A decentralized based email system using The Graph and IPFS
Minimalist, stable, modular, fast, and ZK native implementation of the Ethereum protocol in Rust. L1 and L2 execution client.
Conway's Game of Life in Rust and WebAssembly
Cairo bytecode compiler
cairo-by-example.com
🎨 IPFS Alternative HTTP Interface
A Rust implementation of the BitTorrent V2 protocol
A compiler to convert Cairo's intermediate representation "Sierra" code to MLIR.
A compiler to convert Cairo's intermediate representation "Sierra" code to MLIR.
Yul precompile library to speedup elliptic curves operations.
Export Circom verifier to Cairo
Zero Knowledge Virtual Machine from scratch implementing Pinocchio
Arkworks made simple for us: the non cryptographer software plumbers
Aleo's Minimum Anti-Collusion Infrastructure / MACI
Simple wordpress replacement coded in Elixir + Phoenix + Ecto + PostgreSQL + Docker
The simplest, safest way for AI agents to use Ethereum or any EVM chain. Send, swap, and bridge stablecoins in one line of code with spending limits and human approval flows built in.
Low level (VHDL) hardware description for MSM acceleration over FPGA
Erlang workshop
Export Circom verifier to Cairo
cairo-rs-py adds Python bindings to the cairo-rs Cairo VM
AFK Gacha Game is an autobattler by LambdaClass
Elixir implementation of an Ethereum consensus client, which offers high reliance & fault tolerance
Tendermint implementation of the blockchain of Aleo verifiable computing model built by LambdaClass
Small exercises to get you used to reading and writing Julia code!
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 Weightless Neural Network
Tendermint Consensus is a minimalistic implementation of the BFT consensus algorithm to securely replicate state machines on multiple machines.
Digital Communications Conference in Buenos Aires, Argentina
Starknet Stack let's you easily create new Cairo Starknet chains with their own sequencers, provers and verifiers
Arkworks implementation of the VM of Aleo verifiable computing model built by LambdaClass
An up to date riak_core tutorial, using basho's riak_core, Erlang/OTP 23-24-25 and rebar3.
Multiplayer 2D physics engine, matchmaking, market and leaderboard for 2D and 3D Games
An ABI compatible for KZG EIP-4844 in Rust
A Rust library for decoupling concurrency from application logic, following the model used by Erlang and the BEAM VM
Anonymity Research Tools for TCash Users
Wrapper to Riak Core for Elixir
Trying to achieve a few millions requests per second with different languages, libraries and protocol
A Rust library providing a builder API to generate Cairo code
Cairo finance utilities
Debt crisis
Stark Compass: the only open source explorer
A Rust implementation of Starknet execution logic
Docs and utils for the Zero-knowledge state bridge from Mina to Ethereum
A collection of fuzzers built using Honggfuzz and Cargofuzz tools
Proof of concept Rust implementations for various distributed systems protocols
Design and coding standards for LambdaClass
Little handbook about distributed systems and the evolution of some consensus protocols
Stark Compass: the only open source explorer
new system programming language ideas
Open source engine developed by LambdaClass
Barknet explorer
A Rust implementation of Starknet execution logic
─── peer developers
─── ecosystems
─── languages
- Rust35
- Elixir8
- Python4
- HTML3
- Erlang2
- Jupyter Notebook2
- TypeScript2
- Go2
- LLVM1
- Shell1
─── subscriber view
Unlock the full view of unbalancedparentheses
- · Full repository, commit, and contributor breakdown
- · Peer graph + ecosystem links
- · Weekly trend deltas and pulse signal
- · API + CSV / JSON exports
Already a subscriber? Sign in with the same email used at checkout.