0.99 RLUSDa pass, 24 hours of reading
The Graphicle

“All the code that's fit to read” · a reading room for coding agents

169 hoursof indexing on the shelf, done
The shelf · 63 repositories · 712 MB of source · 46,327 files

Every codebase on the shelf

By language, as each repository's own host counts it. Every one is served whole, and re-indexed every night. The front page · Add a repository · as data

By language

by language, as each repository's own host counts it · every one served whole

Go

quic-go/quic-go

A pure-Go QUIC implementation with HTTP/3 support

quic-go is a pure-Go implementation of the QUIC transport protocol (RFC 9000), with HTTP/3 support on top. It targets developers who need connection-multiplexed networking in Go without CGO — the same library behind projects like Caddy, Syncthing and Traefik. The module is `github.com/quic-go/quic-go`, MIT licensed, and declares Go 1.26 in `go.mod`; the latest release tag is v0.65.0. It also implements additional QUIC and HTTP/3 specifications, including RFC 9221 datagrams, DPLPMTUD (RFC 8899), QUIC Version 2 (RFC 9369) and QPACK.

MIT · 3 MB · 514 files · indexed Nov 17, 2026 · 13 h to index

Go 99.8% · Shell 0.1%

Rust

xai-org/x-algorithm

X publishes its For You feed algorithm as open source

xai-org/x-algorithm is the code that decides what appears in the For You timeline on X. It combines followed-account posts with ML-retrieved out-of-network candidates, ranks them with a multi-action transformer model called Phoenix, and applies separate visibility rules that can drop or gate any post. Released under Apache-2.0 for transparency, it spans roughly 40 components from candidate sources to label-based filtering.

Apache-2.0 · 19 MB · 2,395 files · indexed Nov 16, 2026 · 17 h to index

Rust 47.2% · Python 28.7% · Scala 16.3% · Java 5.2% · …

TypeScript

anomalyco/opencode

MIT · 153 MB · 11,485 files · indexed Nov 18, 2026 · 37 h to index

TypeScript 85.0% · MDX 10.8% · CSS 3.0% · Rust 0.9% · …

Other

8rank/iknow

iKnow opens Apple's personal knowledge graph on your own Mac

iKnow is a small local web app for macOS users who want to see what their computer knows and infers about them. It reads Apple's personal knowledge graph live from `~/Library/IntelligencePlatform`, plus the Messages, Photos, Calendar and Contacts stores it resolves against, and renders people, relationships, faces and inferences in the browser. Everything stays on the machine: a single Python standard-library server binds loopback, every SQLite handle opens read-only, and nothing is written or logged.

Apache-2.0 · 2 MB · 44 files · indexed Nov 9, 2026 · 0.00 h to index

a8m/pb

pbr: a terminal progress bar library for Rust CLIs

pbr is a small Rust crate that draws terminal progress bars in single- or multi-threaded CLI programs. It offers `ProgressBar`, a thread-safe `MultiBar` for several concurrent bars, byte-aware speed display via `Units::Bytes`, configurable bar characters, and a `PbIter` wrapper that turns any iterator into a counted loop. Tested on macOS, Linux and Windows, with WASI stubs included.

MIT · 4 MB · 21 files · indexed Nov 9, 2026 · 0.00 h to index

abadojack/whatlanggo

whatlanggo: natural language and script detection for Go

whatlanggo is a pure-Go natural-language detection library covering 84 languages plus Unicode scripts. It has no external dependencies, exposes `Detect` and `DetectWithOptions`, and returns an `Info` struct with language, script and confidence so callers can judge reliability themselves. Built on the classic Cavnar–Trenkle trigram model, it derives from Franc and takes its idea and algorithms from whatlang-rs.

MIT · 324 KB · 22 files · indexed Nov 9, 2026 · 0.00 h to index

achanda/ipnetwork

ipnetwork: a Rust library for parsing and working with IP CIDRs

ipnetwork is a Rust library (v0.21.1) for representing IPv4 and IPv6 CIDR ranges as typed values. It parses CIDR strings like `10.9.0.32/16` into `Ipv4Network`, `Ipv6Network`, or the unifying `IpNetwork` enum, then offers membership checks, network/broadcast/mask math, subnet relations, and address iteration. Optional serde and schemars features are opt-in. It is dual-licensed Apache-2.0 OR MIT and marked passively maintained.

Apache-2.0 OR MIT · 100 KB · 20 files · indexed Nov 9, 2026 · 0.00 h to index

alrevuelta/rs-merkle-tree

rs-merkle-tree: a fast, fixed-depth Merkle tree with pluggable stores

rs-merkle-tree is a Rust Merkle tree library built around two deliberate constraints: every proof has the same size (the tree's `DEPTH`), and leaves are only ever appended. Intermediate nodes are stored eagerly so proofs can be fetched in one batched read instead of recomputed, which makes retrieval fast at the cost of disk space. It ships five storage backends behind Cargo features, two hash functions including Poseidon for BN254 circuits, and a small `add_leaves`/`root`/`proof` interface.

MIT · 111 KB · 21 files · indexed Nov 9, 2026 · 0.00 h to index

andreimerlescu/bip39

A Go package exposing the BIP39 English word list as a slice

`andreimerlescu/bip39` is a minimal Apache-2.0 licensed Go module that ships the complete BIP39 English word list as an exported slice named `Dictionary`. It has no dependencies and does nothing else — no generation, validation or checksumming. For developers who need the canonical 2,048 words in-process for their own mnemonic tooling.

Apache-2.0 · 32 KB · 5 files · indexed Nov 9, 2026 · 0.00 h to index

andreimerlescu/bump

Bump is a Go CLI that reads and increments version strings in common project files

Bump is a small Apache-2.0 Go utility (v1.1.0) that reads a version string from a file and increments it on demand: `bump -patch`, `-minor`, `-major`, or pre-release steps like `-alpha` and `-rc`. It targets developers who want deterministic, scriptable version bumps in CI pipelines, with exit codes for success and failure. Beyond a plain `VERSION` file it can parse and rewrite versions inside go.mod, package.json, pom.xml, Chart.yaml and Dockerfile, and its defaults are tunable through environment variables.

Apache-2.0 · 13 MB · 34 files · indexed Nov 9, 2026 · 0.00 h to index

andreimerlescu/checkfs

CheckFS validates files and directories against declarative options in Go

CheckFS is a Go utility for validating files and directories through declarative `Options` structs. It covers existence, read/write permissions, owner and group (as UID/GID strings), base-directory containment, timestamps, size bounds, extension and prefix rules, and exact or relative file modes. An embedded `Create` type can make the missing resource on demand, with a destructive replace mode. Built for Go 1.20+, Apache-2.0.

Apache-2.0 · 64 KB · 18 files · indexed Nov 9, 2026 · 0.00 h to index

andreimerlescu/concert

Concert: a FIFO waiting-room reverse proxy that shields fragile origins

Concert is an Apache-2.0 Go reverse proxy that puts a first-in-first-out waiting room in front of any HTTP origin. When traffic exceeds the page capacity you set, visitors wait with a live queue position instead of hitting 502s; admitted visitors get a signed pass for assets and streams, and misbehaving clients are banned on escalating cooldowns. It is built on the author's `room`, `sema` and `naddr` libraries, ships an admin portal and RHEL installer, and targets PHP-FPM and other origins that fall over under load.

Apache-2.0 · 4 MB · 137 files · indexed Nov 9, 2026 · 0.00 h to index

andreimerlescu/configure-ebs

configure-ebs.sh formats and mounts AWS EBS volumes for GitLab

configure-ebs is a one-file bash tool from Andrei Merlescu that takes an attached AWS EBS volume and turns it into a mounted, boot-persistent directory. It creates the filesystem (xfs or ext4), backs up and patches `/etc/fstab`, mounts by UUID, and installs fstrim scheduling via systemd timer or cron. Written for GitLab servers that need extra volumes for registry, artifacts, uploads, LFS objects, Terraform state and backups.

Apache-2.0 · 22 KB · 4 files · indexed Nov 9, 2026 · 0.00 h to index

andreimerlescu/disk-speed

A single Bash script that times raw read/write speed on any path

A tiny MIT-licensed Bash tool from andreimerlescu that measures sequential disk throughput by writing and reading back a temporary file of a chosen size. It takes a target path, resolves the underlying device via `df`, and uses `dd` to time raw writes and reads. Useful for a quick performance check on a database mount or other filesystem.

MIT · 5 KB · 3 files · indexed Nov 9, 2026 · 0.00 h to index

andreimerlescu/encrypted-luks-workspace

ELWORK manages LUKS-encrypted disk-image workspaces from Bash

A Bash tool that creates and manages LUKS-encrypted disk image files as portable workspaces on Linux. It handles the full lifecycle — new, mount, unmount, remove — with a small set of flags and an index file to track state. Ships with a Dockerfile for testing in a clean Ubuntu 22.04 container.

Apache-2.0 · 58 KB · 12 files · indexed Nov 9, 2026 · 0.00 h to index

andreimerlescu/extra-ssh-bash

extra-ssh-bash runs one command across a Terraform-managed cluster in parallel

extra-ssh-bash is a small Go CLI (with an unfinished bash companion and a Terraform template) for running the same command concurrently across a fleet of EC2 hosts. It reads target IPs from `terraform output`, builds one ssh invocation per host, runs them under a semaphore-limited worker pool, and returns stdout/stderr keyed by address. For operators who manage Docker clusters with GitLab's HTTP Terraform backend.

Apache-2.0 · 4 MB · 21 files · indexed Nov 9, 2026 · 0.00 h to index

andreimerlescu/figtree

Figtree: a Go config manager with validators, callbacks and mutation tracking

Figtree is a command-line configuration manager for Go. It parses flags through the standard `flag` package plus environment variables and YAML, JSON or INI files, with per-property validators, callbacks and an optional mutation-tracking channel. Positioned as a replacement for Viper, it offers per-property validators — the README says 36 built-in, though its own available-validators table lists more and uses the standard `flag` package rather than pflag.

MIT · 1 MB · 55 files · indexed Nov 9, 2026 · 0.00 h to index

andreimerlescu/gematria

Gematria turns any string into six numerology scores in Go

`andreimerlescu/gematria` is a small, dependency-free Go library that converts an input string into six numerological scores — English, Jewish, Simple, Mystery, Majestic and Eights — using per-letter lookup tables. It targets developers who want gematria-style word relationships in their own programs, and it ships simplification, score-combining helpers and tests. Written for Go 1.21 under the Apache-2.0 license.

Apache-2.0 · 41 KB · 13 files · indexed Nov 9, 2026 · 0.00 h to index

andreimerlescu/go-animate-coin

Go tool spins square PNGs into a coin-flip GIF

go-animate-coin is a small MIT-licensed Go command-line program that takes one square, at least 144x144 pixel PNG image and renders it as an animated GIF of the coin rotating toward you in perspective. It exists because its author wanted to animate a meme token's logo and found nothing ready-made online. Single file, no dependencies beyond the standard library, built with Go 1.23.4.

MIT · 696 KB · 10 files · indexed Nov 9, 2026 · 0.00 h to index

andreimerlescu/goenv

goenv: a .env editor that reads, checks, writes and converts env files

goenv is two things in one repository: a command-line utility for working with `.env` files — adding or removing keys, asserting values, printing contents, converting to JSON/YAML/TOML/INI/XML — and an Apache-2.0 `env` Go package that auto-loads `./.env` on import without clobbering variables already set in the environment. It is aimed at developers who script configuration files or need typed access to environment values, with production-file write protection built in.

Apache-2.0 · 100 KB · 30 files · indexed Nov 9, 2026 · 0.00 h to index

andreimerlescu/goini

goini: a flag-driven CLI for reading and editing INI files

goini is a single-purpose Go command-line tool for working with `.ini` configuration files. It reads an INI file with the `github.com/go-ini/ini` parser and exposes operations — listing sections or keys, checking whether a section or key exists, adding or modifying entries — through flags whose success is reported as process exit codes (0 or 1). Output can be plain text, CSV, JSON, or YAML. It targets scripts and automation that need to query or edit INI configs without hand-parsing.

Apache-2.0 · 41 KB · 14 files · indexed Nov 9, 2026 · 0.00 h to index

andreimerlescu/igo

igo installs multiple Go versions side by side in your home directory

`igo` ("Install Go") is a single-purpose command-line utility written in Go for installing and managing multiple versions of the Go runtime. It keeps each version isolated under `~/go/versions`, exposes the active one through symlinks named `root`, `bin` and `path`, and switches between them with `-s`. Aimed at developers who want several toolchains on one machine without touching system packages, it needs no root privileges and runs from a downloaded binary rather than `go install`.

MIT · 16 MB · 35 files · indexed Nov 9, 2026 · 0.00 h to index

andreimerlescu/lemmings

Lemmings — a session-aware load simulator that walks your site like people do

Lemmings is a stateful, navigating HTTP load simulator written in Go, shipped as one self-contained binary. Instead of firing requests at a fixed rate, it spawns virtual browser sessions — each with its own cookie jar, user agent, language and lifespan — that land on your site, follow links, pause like readers, queue in waiting rooms, and report every failure a person would notice. It targets engineers preparing for traffic spikes: launches, sales, TV spots. A live synthwave dashboard shows the swarm walking your terrain; reports deliver locally, to S3 or by email with CI gates and exit codes.

Apache-2.0 · 1 MB · 58 files · indexed Nov 9, 2026 · 0.00 h to index

andreimerlescu/roc

roc runs coding agents in throwaway Docker containers with MCP

roc is a Rust command-line tool for running AI coding agents — opencode by default, plus Claude Code, Codex and goose — inside a throwaway Docker container. It mounts only the folders you choose at their host paths, leases model workers from LM Studio, Ollama or any OpenAI-compatible API, and gives the agent real infrastructure through an MCP gateway with a per-session token. Everything it creates is tracked in a state file and removed on exit.

Apache-2.0 · 610 KB · 44 files · indexed Nov 9, 2026 · 0.00 h to index

andreimerlescu/room

room — a FIFO waiting room middleware for Gin that queues excess traffic

`room` is a single-import gin middleware that turns overflow traffic into an orderly, ticket-numbered queue instead of dropping requests. Built on the `sema` semaphore library, it issues every arrival a ticket, serves excess clients a self-refreshing waiting page with their position, and admits them in order as capacity frees. It adds paid skip-the-line promotions, time-limited VIP passes, export/import persistence across restarts, lifecycle callbacks, an admin read/remove API, and runtime-tunable settings — aimed at Go developers running live events or fragile origins under spike load.

Apache-2.0 · 594 KB · 41 files · indexed Nov 9, 2026 · 0.00 h to index

andreimerlescu/sema

sema: a Go semaphore with live resizing, draining, and utilization metrics

sema is a Go 1.21+ concurrency primitive for bounded parallelism when `golang.org/x/sync/semaphore` falls short. It keeps the weighted acquire/release core but adds dynamic capacity resizing via `SetCap`, graceful drain/reset lifecycle methods, context-aware and timeout acquires, an EWMA utilization signal for autoscalers, and a pluggable observer hook that wires into Prometheus or structured logging with zero overhead when unused. Built on a buffered channel plus mutex/cond coordination, it ships unit tests under the race detector, eight fuzz targets, and benchmarks.

Apache-2.0 · 162 KB · 18 files · indexed Nov 9, 2026 · 0.00 h to index

andreimerlescu/summarize

summarize walks your source tree into one AI-ready Markdown file

`summarize` is a command-line tool for developers who want to hand their whole codebase to an AI. It walks a directory, keeps only files whose extensions you allow, skips binaries and secrets by default, reads the survivors concurrently, and renders one timestamped Markdown file with each file's `os.Stat` info plus full source. Flags and `SUMMARIZE_*` environment variables control include/exclude lists, output size caps, gzip compression, JSON rendering, and an optional Bubble Tea chat session backed by ollama or OpenAI-style providers.

MIT · 1 MB · 26 files · indexed Nov 9, 2026 · 0.00 h to index

andreimerlescu/textee

Textee builds n-gram frequency maps from Go strings, with optional gematria scoring

Textee is a single-purpose Go library for substring analysis: it splits input into sentences, generates every consecutive 1-to-3-word group, cleans and lowercases them, and tallies occurrences in an atomic map. It optionally scores each substring with the author's go-gematria module across six numerological systems. Aimed at log processing, pattern detection and NLP-style text work, it is concurrency-aware by design but small enough to read end to end.

Apache-2.0 · 26 KB · 10 files · indexed Nov 9, 2026 · 0.00 h to index

andreimerlescu/verbose

Verbose scrubs secrets from Go logs before they reach disk

Verbose is a small Apache-2.0 Go logging package (v0.2.0, go 1.23.4) that automatically redacts secrets — passwords, tokens, keys, JWTs — from log output before anything is written to disk. Secrets are registered at runtime as SHA-512 hashes so plaintext never persists in memory, and a built-in pattern list cleans PEM blocks, GitHub/AWS/Stripe credentials, Docker configs and more without registration. Built for concurrent production systems where secrets arrive dynamically.

Apache-2.0 · 2 MB · 25 files · indexed Nov 9, 2026 · 0.00 h to index

antchfx/xpath

antchfx/xpath is a dependency-free XPath engine for Go

antchfx/xpath is a small MIT-licensed Go library (255 KB, 26 files) that compiles and evaluates XPath expressions against XML, HTML or JSON documents — or any custom node tree you can adapt to its `NodeNavigator` cursor interface. It backs the htmlquery, xmlquery and jsonquery packages and ships with zero external dependencies. For developers who need standards-style path queries in Go without pulling in a browser engine.

MIT · 256 KB · 26 files · indexed Nov 13, 2026 · 0.00 h to index

apache/sedona-db

SedonaDB brings single-node spatial SQL to Python and Rust on DataFusion

SedonaDB is an open-source, single-node analytical database engine built in Rust on top of Apache Arrow and Apache DataFusion, with geospatial types treated as native citizens rather than add-ons. It targets developers who need fast spatial range queries, KNN, and joins over small-to-medium datasets on a local machine or cloud instance, offering Python and SQL interfaces plus R bindings. For distributed workloads the project points users to SedonaSpark, SedonaFlink, and SedonaSnow.

Apache-2.0 · 27 MB · 1,498 files · indexed Nov 15, 2026 · 0.01 h to index

ardaku/whoami

whoami: a Rust crate for reading user and environment details across platforms

whoami is a small Rust library (v2.1.3) whose public functions return facts about the current user and machine — full name, username, preferred languages, hostname, device "pretty name," OS distribution, desktop environment, platform and CPU architecture. It targets everything Rust runs on, from Linux and Windows to Redox and WebAssembly, routing each call through a per-platform `Target` implementation selected at compile time. Built for tooling that needs portable identity and system detection through a simple no-argument API.

Apache-2.0 OR MIT · 164 KB · 57 files · indexed Nov 9, 2026 · 0.00 h to index

arroyosystems/arroyo

Arroyo is a Rust stream processor that turns SQL into fault-tolerant pipelines

Arroyo is an open-source distributed stream processing engine written in Rust. You write stateful pipelines in SQL, and the system compiles them into a dataflow graph of operators that run across workers with checkpointing for fault tolerance and recovery. It targets developers who want real-time analytics without hand-writing streaming code, and ships as a single binary plus a web UI.

Apache-2.0 OR MIT · 21 MB · 662 files · indexed Nov 15, 2026 · 0.01 h to index

asynkron/protoactor-go

Proto Actor for Go — a distributed actor framework built on gRPC and Protobuf

Proto Actor is the Go implementation of the Proto Actor framework, an actor-model runtime that also ships for C#. It keeps a deliberately small API, builds networking on gRPC and serialization on Protocol Buffers, and adds optional remoting, cluster membership with grains, routing, persistence and testing helpers. Still in beta until 1.0, it is aimed at developers who want distributed, fault-tolerant concurrency without building their own transport or serialization layers.

Apache-2.0 · 2 MB · 670 files · indexed Nov 9, 2026 · 0.00 h to index

avr-rust/ruduino

Ruduino: reusable register-level components for AVR microcontrollers

Ruduino is a `no_std` Rust crate from the AVR-Rust project that provides reusable, low-level components for AVR microcontrollers such as the ATmega328P on an Arduino Uno. It ships generated per-chip register and pin definitions plus timer, USART serial and SPI modules, with builder-style setup for timers and serial, plus interrupt handling helpers. Built for bare-metal embedded work without `std`, it targets nightly Rust features and is dual-licensed MIT/Apache-2.0.

Apache-2.0 OR MIT · 824 KB · 48 files · indexed Nov 9, 2026 · 0.00 h to index

awnumar/memguard

MemGuard keeps secrets encrypted and guarded in Go memory

MemGuard is a pure-Go library for keeping sensitive data safe while it lives in process memory. It encrypts secrets at rest inside Enclaves using XSalsa20Poly1305, allocates guarded plaintext regions through kernel syscalls instead of the Go runtime, and rekeys continuously to blunt cold-boot attacks. It is written in pure Go and aims to support all major operating systems.

Apache-2.0 · 328 KB · 49 files · indexed Nov 9, 2026 · 0.05 h to index

bevyengine/bevy

Bevy: a data-driven Rust game engine built on ECS

Bevy is an open-source Rust game engine organized as a Cargo workspace, with all official crates under the `crates/` folder. Everything from rendering to input is a plugin; game code expresses itself through the Entity Component System paradigm in a `World`. It targets desktop, mobile, web (Wasm), and no_std platforms, with runnable examples.

Apache-2.0 OR MIT · 87 MB · 3,213 files · indexed Nov 15, 2026 · 0.02 h to index

bits-and-blooms/bitset

bitset: a Go library for dense, fast integer-to-boolean sets

bits-and-blooms/bitset is a mature Go library that maps non-negative integers to boolean values in a packed array of 64-bit words. It offers individual bit operations plus full set algebra (intersection, union, difference, complement), cardinality queries, portable serialization and iteration over set bits. Aimed at developers who need dense membership sets faster than `map[uint]bool`, it is used widely across databases, search engines, blockchains and infrastructure tooling.

BSD-3-Clause · 732 KB · 34 files · indexed Nov 15, 2026 · 0.61 h to index

blitzarx1/egui_graphs

egui_graphs brings interactive graph widgets to Rust's egui framework

egui_graphs is a Rust library that adds an interactive `GraphView` widget to the egui GUI framework. It wraps a `petgraph` graph with zooming, panning, node dragging, click/hover reporting, pluggable layouts and custom renderers, and builds for native or WASM. Aimed at developers who want a basic, extensible graph engine inside an existing egui application rather than a standalone tool.

MIT · 592 KB · 85 files · indexed Nov 9, 2026 · 0.14 h to index

bobg/merkle

bobg/merkle: streaming Merkle roots and inclusion proofs in Go

`github.com/bobg/merkle/v2` is a MIT-licensed Go package for computing the Merkle root hash of a sequence of byte strings, or of their leaf hashes, without holding all input in memory. It also produces compact inclusion proofs that let a verifier confirm one string belongs to a tree given only its root. Aimed at developers who need Merkle roots or membership proofs over unbounded streams of byte strings.

MIT · 27 KB · 10 files · indexed Nov 9, 2026 · 0.00 h to index

bootandy/dust

dust — a friendlier `du` that draws disk usage as bars

dust is an Apache-2.0 command-line tool written in Rust that reports which directories use your disk space without needing `sort` or `head`. It walks a directory tree with Rayon parallelism, deduplicates hard links by inode, and renders the largest entries as proportional bars whose grey shades show parent-child ownership. Aimed at command-line users who want an instant overview of disk usage.

Apache-2.0 · 610 KB · 54 files · indexed Nov 9, 2026 · 0.26 h to index

bparli/convey

Convey, a layer-4 load balancer in Rust with three forwarding modes

Convey is a small MIT-licensed Rust load balancer that forwards TCP at layer 4. It runs in one of three modes — terminating proxy, passthrough NAT, or direct server return (DSR) — reads its backend pool from a TOML file it watches for changes, and health-checks servers over TCP so unhealthy backends drop out of selection automatically. A stats page at `/stats` reports basic connection/bytes counters and backend pool statuses.

MIT · 168 KB · 21 files · indexed Nov 9, 2026 · 0.15 h to index

breeze0806/go-etl

go-etl: a Go ETL toolkit with a DataX-style sync framework

go-etl is an Apache-2.0 Go toolset for extracting, transforming and loading data across mainstream databases and two-dimensional file streams. Its `datax` package re-creates the Reader/Writer/Framework architecture of Alibaba's DataX as a single offline synchronization engine with plugins for MySQL, Postgres, DB2, SQL Server, Oracle, Sqlite3, Dameng, CSV and XLSX. It is aimed at developers who want database-to-database or file-to-database batch sync in Go without using the original DataX implementation.

Apache-2.0 · 2 MB · 524 files · indexed Nov 9, 2026 · 0.32 h to index

build-trust/ockam

Ockam: end-to-end encrypted, mutually authenticated communication for distributed apps

Ockam is a library and command-line tool for building devices that communicate with cloud services and other devices over end-to-end encrypted, mutually authenticated channels. It adds application-layer routing across multiple transports so messages stay protected beyond any single connection, plus identity, credential exchange and attribute-based access control. The repository is a monorepo holding Rust crates and an Elixir implementation under one Makefile.

Apache-2.0 · 8 MB · 2,178 files · indexed Nov 9, 2026 · 1.2 h to index

caddyserver/caddy

Caddy v2: a modular Go web server that does HTTPS by default

Caddy is an open-source (Apache-2.0) web server and general-purpose long-running application platform written in Go. It enables HTTPS automatically by default via ZeroSSL and Let's Encrypt, ships HTTP/1.1 through HTTP/3, and organizes everything around a namespaced module system with JSON as the native config language. Built for developers who want TLS without ceremony and extensibility without bloat.

Apache-2.0 · 5 MB · 780 files · indexed Nov 15, 2026 · 0.00 h to index

ccbrown/iocraft

iocraft brings React-style declarative UIs to Rust terminals

iocraft is a Rust library for building terminal interfaces and styled text output through a declarative, React-like API. You declare UI with the `element!` macro, build custom components with `#[component]`, manage state with hooks, and let taffy lay out your views as flexbox before rendering to a canvas and then the terminal. It targets developers who want readable, composable CLIs and fullscreen TUIs on Unix and Windows.

Apache-2.0 OR MIT · 6 MB · 109 files · indexed Nov 14, 2026 · 0.94 h to index

centrifugal/centrifugo

Centrifugo, a scalable real-time PUB/SUB messaging server in Go

Centrifugo is an open-source, language-agnostic real-time messaging server written in Go. It delivers messages to online users over WebSocket, HTTP-streaming, Server-Sent Events, GRPC and WebTransport, built around channel subscriptions — a user-facing PUB/SUB model. Backends publish through a simple HTTP or GRPC API while clients subscribe using official SDKs. It scales with Redis (or compatible stores), PostgreSQL or NATS, with hot message history, recovery, presence and an embedded admin UI.

Apache-2.0 · 15 MB · 565 files · indexed Nov 10, 2026 · 0.93 h to index

chanify/chanify

Chanify: a self-hosted push notification server for iOS with MCP tooling

Chanify is an MIT-licensed Go server that delivers notifications to iOS and macOS clients through Apple's APNS. It runs as a self-hosted node in either stateless or stateful mode, exposes a simple HTTP API for sending text, links, images, audio and files, and ships with CLI tools. Version 1.5 includes MCP integration and a web admin panel; the current README also documents one-shot agent sending and local stdio MCP.

MIT · 789 KB · 152 files · indexed Nov 15, 2026 · 0.40 h to index

charmbracelet/bubbles

Bubbles: ready-made TUI widgets for Bubble Tea apps

Bubbles is Charm's collection of reusable UI components for Bubble Tea terminal applications — text input, textarea, table, list, viewport, spinner, progress meter, paginator, file picker, timer, stopwatch and help views. It ships as a Go module under the MIT license, now at v2 with a companion upgrade guide. For developers building full-screen terminal tools in Go.

MIT · 478 KB · 106 files · indexed Nov 10, 2026 · 0.35 h to index

charmbracelet/bubbletea

Bubble Tea: an Elm-architecture framework for terminal apps in Go

Bubble Tea is Charm's MIT-licensed Go framework for building terminal applications on The Elm Architecture. You write three methods — `Init`, `Update`, and `View` — and the library supplies the event loop, raw-mode input handling, keyboard and mouse parsing, clipboard support, color downsampling, and a high-performance cell-based renderer whose flush reports whether anything was drawn. It is in production use across thousands of applications and ships as module `charm.land/bubbletea/v2`.

MIT · 3 MB · 238 files · indexed Nov 14, 2026 · 0.62 h to index

constantoine/totp-rs

totp-rs: a no_std, RFC-compliant TOTP library with a builder API

totp-rs is a MIT-licensed Rust crate that generates and verifies RFC 6238/4226 time-based one-time passwords. Version 6 introduces a `Builder` API with compliance checks, keeps default features lightweight for small binaries, and runs without `std` or even an allocator on embedded targets. It offers optional otpauth URL parsing, QR code output, Steam tokens, serde support and secret zeroization.

MIT · 191 KB · 23 files · indexed Nov 10, 2026 · 1.0 h to index

cool-japan/scirs

SciRS2: a pure-Rust SciPy port with AI/ML modules

SciRS2 is a large Rust workspace that ports the scientific-computing stack to pure Rust. It aims for SciPy-compatible APIs across linear algebra, statistics, FFT, signal processing and more, then adds AI/ML crates for autograd, neural networks, graphs and vision. Its selling point is zero C/C++/Fortran dependencies by default — BLAS/LAPACK via OxiBLAS, FFT via OxiFFT — so `cargo add scirs2` works without system libraries. For developers who want a memory-safe, cross-platform SciPy alternative.

Apache-2.0 · 171 MB · 8,795 files · indexed Nov 10, 2026 · 0.12 h to index

dathoangnd/gonet

gonet, a compact multi-layer neural network for Go

gonet is a tiny pure-Go module (about 15 KB) implementing multi-layer neural networks trained by backpropagation. It offers a `New`/`Config` constructor, a `Train` loop over epochs, `Predict`, and JSON-based `Save`/`Load`. Aimed at developers who want a dependency-free network for small classification or regression tasks without pulling in a machine-learning framework. Last released as v1.0.1; the code has been unmaintained since 2020.

MIT · 15 KB · 11 files · indexed Nov 10, 2026 · 0.00 h to index

derailed/k9s

k9s: a terminal UI for managing Kubernetes clusters

k9s is an open-source terminal user interface for interacting with Kubernetes clusters. It continuously watches cluster state and offers commands to observe, edit, delete and port-forward resources without leaving a terminal. Written in Go against the official client-go libraries, it is aimed at people who want to navigate, observe and manage Kubernetes applications from a terminal.

Apache-2.0 · 9 MB · 1,099 files · indexed Nov 15, 2026 · 5.5 h to index

dimforge/nalgebra

nalgebra, Rust's general-purpose linear algebra library

nalgebra is an actively developed Rust linear-algebra crate for scientific computing and, through its GLM companion, graphics-style work. Matrix types handle compile-time- and runtime-sized vectors and matrices; the repository includes GLM-style bindings, LAPACK backends, sparse formats, and construction macros. It is Apache-2.0 on edition 2024 with a minimum Rust of 1.89.0, and it runs without a standard library: separate `no-std` feature paths cover serialization via serde or rkyv and randomness through rand, so no-std targets can use the crate with separate serialization and randomness features.

Apache-2.0 · 3 MB · 458 files · indexed Nov 11, 2026 · 6.6 h to index

doom-fish/screencapturekit-rs

Safe Rust bindings for Apple's ScreenCaptureKit on macOS

screencapturekit is a safe, idiomatic Rust crate wrapping Apple's ScreenCaptureKit framework for capturing screens, windows and applications with system audio (macOS 13+ at run time) and feature-gated microphone capture (macOS 15+). It offers a builder-pattern synchronous API, an optional waker-based async layer that works with any executor, zero-copy IOSurface/Metal access, screenshots, direct-to-file recording and the system content picker. Foundation types are shared through the thin apple-cf and apple-metal crates; native calls go through a Swift bridge built by build.rs.

Apache-2.0 OR MIT · 2 MB · 175 files · indexed Nov 11, 2026 · 6.6 h to index

dora-rs/dora

Dora: a Rust robotics framework that runs multi-language nodes as YAML dataflows

Dora is an Apache-2.0, all-Rust framework for building real-time robotics and AI applications as declarative YAML dataflows of connected nodes. Nodes can be written in Rust, Python, C or C++ and mixed freely; local shared memory and a Zenoh data plane move Arrow-encoded messages between them, with zero-copy IPC for payloads over 4 KB. It targets developers building real-time robotics and AI applications; the README claims it is 10-17x faster than ROS2 Python.

Apache-2.0 · 15 MB · 1,329 files · indexed Nov 15, 2026 · 14 h to index

elastic/go-elasticsearch

The official Go client for Elasticsearch, low-level and typed

go-elasticsearch is Elastic's official Go client for Elasticsearch, licensed under Apache-2.0 and currently released as v9.5.2. It ships two ways to talk to a cluster: a low-level `esapi` surface, and a typed API, including the `esdsl` query builders referenced in the README. An `esutil` package adds helpers such as `BulkIndexer`. For Go programs that must index into or query Elasticsearch.

Apache-2.0 · 30 MB · 6,749 files · indexed Nov 15, 2026

ellisonch/rust-stopwatch

A tiny Rust stopwatch crate for timing code

A minimal Rust crate named `stopwatch` (v0.0.7) that times how long a block of code takes to run. It offers a small set of methods — new, start_new, start, stop, reset, restart, is_running, elapsed and elapsed_ms — for timing work in tests or other code. MIT-licensed, about 8 KB across seven files, last touched in November 2017.

MIT · 8 KB · 7 files · indexed Nov 15, 2026

ferrismind/shadcn-rs

Apache-2.0 OR MIT · 72 MB · 1,080 files · indexed Nov 20, 2026 · 33 h to index

gitea.com/xorm/xorm

Xorm: a battle-tested Go ORM with struct-to-table mapping

Xorm is an open-source object-relational mapper for Go that maps structs to tables across multiple SQL databases including MySQL, Postgres, CockroachDB, SQLite and Microsoft SQL Server. It offers a chainable query builder, transactions, schema sync, read/write splitting through engine groups, caching, and a migration package. Used by projects including Gitea, Gogs and Grafana. It is BSD-3-Clause licensed, and the latest release tag is v1.4.3.

BSD-3-Clause · 2 MB · 231 files · indexed Nov 9, 2026 · 0.00 h to index