This repository contains a collection of example applications demonstrating the use of the gnet networking library in Go. The examples cover various networking paradigms including TCP, UDP, Unix domain sockets, HTTP, WebSocket, and a custom binary protocol. Each example is a standalone program showcasing event-driven connection handling, message parsing, and protocol implementation using gnet's APIs. Key examples include echo servers for different transports, an HTTP server using wildcat for parsing, a push server broadcasting periodic messages, a simple protocol client/server with a custom framing codec, and WebSocket implementations using both gobwas/ws and a custom RFC 6455-compliant codec. The code illustrates gnet's event loop patterns, connection context usage, and efficient I/O handling. While the examples are generally idiomatic and functional, some dependencies show mild technical drift (e.g., the wildcat HTTP parser is outdated). The repository is actively maintained with recent commits and serves as a practical reference for learning gnet-based network programming in Go.
MAGSAC is a C++ library with Python bindings (pymagsac) implementing robust model fitting algorithms for computer vision, including homography, fundamental matrix, essential matrix, rigid transformation, and 2D line estimation. The core algorithm is a template class `MAGSAC<DatumType, ModelEstimator>` that supports sigma-consensus and MAGSAC++ scoring, with interchangeable sampling strategies (uniform, PROSAC, P-NAPSAC, NG-RANSAC, AR-Sampler) and adaptive inlier selection. The Python API mirrors the C++ functionality via pybind11, accepting numpy arrays for point correspondences and returning estimated models with inlier masks. The repository also includes benchmark datasets and Jupyter notebook examples demonstrating usage. While the library is primarily a software package, it contains research-grade data and notebooks, giving it a hybrid character. The code is well-architected with clean separation of concerns, though it has minor maintenance risks such as memory management caveats and limited platform support (Linux/Windows only).
Sdl.MultiSelectComboBox is a WPF custom control library distributed as a NuGet package that provides a multi-selection combo box for Windows desktop applications. The control renders selected items as removable tags in a wrap panel, supports live text filtering, grouped dropdown lists, autocomplete, async suggestion loading, keyboard-driven selection (Space, Return, Shift+click range selection, Delete/Backspace to remove), disabled-item awareness, single/multiple selection modes, and read-only vs. edit visual states. The example project is a language picker that demonstrates every feature with flag icons, a settings panel, custom control templates, and an event log.
MMSearch is a framework for evaluating large multimodal models (LMMs) as multi-modal search engines. It provides a pipeline (MMSearch-Engine) that enables any LMM to perform multimodal search by generating queries, retrieving web content, reranking results, and summarizing answers. The repository includes evaluation scripts for four tasks (end2end, requery, rerank, summarization) and a demo for running the engine on custom queries. The system relies on external dependencies like DuckDuckGo search, Playwright for web scraping, and Hugging Face datasets. The architecture is modular with separate components for model loading, prompt templating, web retrieval, content processing, and scoring.
This repository serves as a reference guide and checklist for attending events, particularly the Chaos Communication Congress (CCC) series. It consists of three main markdown files: a comprehensive attendee checklist (README.md), a directory of communication channels for CCC events (CCCongress Info Channels.md), and emergency information for a specific event (39C3 Emergency Info.md). The content is organized to help participants prepare for, navigate, and follow up after events, covering topics from packing lists and safety procedures to communication methods and post-event activities. While primarily documentation rather than software, it functions as an active tool that users consult and update via pull requests.
cargo-sweep is a Cargo subcommand designed to selectively clean unused build artifacts from Rust project target directories. It operates based on various criteria such as file age, installed Rust toolchains, or target directory size limits, allowing users to reduce disk usage without performing a full 'cargo clean'. The tool is implemented as a standalone Rust binary that integrates with Cargo's metadata system to locate projects and analyze their build artifacts. The architecture centers around a modular design where command-line argument parsing (using clap) feeds into a criterion-based cleaning system. Key components include a sophisticated fingerprinting module that replicates Cargo's internal mechanism for associating build artifacts with specific Rust compiler versions, a timestamp handling system for time-based cleaning, and utility functions for human-readable byte formatting. The tool recursively discovers Cargo projects, evaluates which artifacts to retain based on the selected criterion, and safely removes the rest. Despite its technical sophistication, the project carries a maintenance warning in its README indicating it is currently unmaintained and lacks a dedicated maintainer. This is reflected in outdated dependencies (particularly cargo_metadata at version 0.9 versus the latest 0.18.0) and the project's reliance on the original author for issue triage and pull request reviews. While the code demonstrates strong engineering practices and reusable components, its future viability depends on renewed community stewardship.
This repository is a collection of Home Assistant blueprints (YAML automation and script templates) that enable voice-controlled music playback via the Music Assistant integration. It provides three distinct options: a fully local intent-based automation using custom conversation triggers, an LLM-enhanced automation that leverages an external LLM conversation agent to parse natural language queries, and an LLM script that can be used as a tool by LLM conversation agents for more flexible music requests. The blueprints are well-structured with multi-language support (English, Dutch, French, German, Hungarian, Italian, Portuguese, Slovak, Spanish, Finnish) and demonstrate advanced use of Home Assistant's conversation triggers, Jinja2 templating, and integration with Music Assistant's play_media service. The repository is community-driven and actively maintained, with detailed documentation and changelogs. While tightly coupled to Home Assistant and Music Assistant, the blueprints exhibit good craftsmanship in handling target resolution, shuffle logic, and LLM prompt engineering.
SmokeDetector is a headless chatbot that monitors Stack Exchange sites in real time for spam and offensive content. It connects to the Stack Exchange WebSocket to receive new posts and edits, fetches post bodies via the Stack Exchange API, and runs them through a large set of regex-based blacklists, watchlists, and heuristic rules (including phone number deobfuscation, DNS lookups, and homoglyph detection). When spam is detected, the bot reports it to designated chat rooms and a companion web service called Metasmoke, which provides statistics, feedback, and blacklist management. The system is designed for continuous operation, with Docker deployment, crash recovery, and automated git-based updates for blacklists. The architecture is a monolithic Python application with heavy use of threading for concurrent post scanning, chat communication, and periodic tasks. Key subsystems include a real-time post scanner (bodyfetcher.py), a rule-based detection engine (findspam.py), a chat command interface (chatcommands.py), and a client for the Metasmoke API (metasmoke.py). State is persisted via pickle files, and configuration is spread across YAML, text files, and a global singleton (globalvars.py). The codebase also includes a simple async task scheduler (tasks.py), a generic TTL cache (metasmoke_cache.py), and an inter-instance communication protocol (socketscience.py). While primarily an application, the repository contains substantial data assets in the form of curated blacklists and watchlists (keywords, websites, phone numbers, CIDRs, nameservers) that are actively maintained and tuned based on true/false positive ratios. These data files are used by the detection engine and represent a significant research effort into spam patterns and obfuscation techniques. The bot's functionality is tightly coupled to the Stack Exchange platform and the Metasmoke service, making it less portable to other domains without significant adaptation.
Eko is a TypeScript framework for building production-ready AI agents that can automate workflows across browser, Node.js, and web extension environments. The core orchestration engine (Eko class) takes a natural language task, uses an LLM to generate a multi-agent workflow plan encoded as XML, then executes it with parallel/serial agent execution, replanning, and human-in-the-loop support. The system provides a clean abstraction over LLM providers (OpenAI, Anthropic, etc.) with retry and fallback, a ReAct tool-calling loop, and built-in browser automation agents that operate via screenshots or DOM labels. It also includes MCP client implementations (SSE, HTTP, stdio) for integrating external tools, and a chat agent for conversational interactions with tool delegation. The architecture is modular with separate npm packages: @eko-ai/eko-core (core engine), @eko-ai/eko-nodejs (Playwright-based browser agent), @eko-ai/eko-extension (Chrome extension agent), and @eko-ai/eko-web (web environment agent). The repository includes working examples (Chrome extension with side panel, Node.js automation using Playwright, and a React web app). The framework is designed for developers who want to automate complex, multi-step tasks using language models, with a focus on reliability, human oversight, and extensibility via custom agents and tools.
This repository is the official blog for the 'Web Dev Simplified' educational brand, built with Astro as a static site generator. It contains hundreds of MDX tutorial articles covering JavaScript, CSS, React, TypeScript, and other web development topics, published on a strict Monday schedule. The architecture is a static blog with selective client-side interactivity via React components (islands) embedded in articles to demonstrate concepts. Key infrastructure includes a custom theme system with light/dark mode, Plausible analytics with a custom proxy, ConvertKit newsletter integration, dynamic Open Graph image generation using Satori/Sharp, and a set of custom Remark plugins for YouTube embeds, responsive images, and syntax highlighting with line highlights. Deployment is on Netlify with redirect handling and RSS feed generation. The content creation pipeline is augmented by AI agent skills defined in the `.agents/` directory, which enforce a strict writing style and publishing workflow. While the codebase is well-organized and demonstrates solid engineering practices for a content site, it carries some technical debt including a pinned outdated Node.js version (v17.9.0), use of deprecated Shiki API, and a dead service worker that only self-unregisters. The docs/ directory contains comprehensive guides but has drifted from the actual code version (references Astro 2.4.5 while using 3.6.5). Overall, it is a well-crafted, feature-rich blog platform with reusable patterns in its utility modules and plugins.
HILO-MPC is a Python toolbox for machine-learning-supported optimal control and estimation, developed at TU Darmstadt and Otto von Guericke University. It provides a comprehensive set of controllers (NMPC, LMPC, PID, LQR), state estimators (MHE, Kalman filters, particle filter), and machine learning models (Gaussian processes, neural networks) that can be integrated into control loops. The architecture is built on CasADi for symbolic differentiation and optimization, with a plugin system for backends (PyTorch, TensorFlow, scikit-learn) and visualization (Matplotlib, Bokeh). The toolbox supports ODE/DAE modelling, linearization, discretization, and code generation for embedded deployment. The codebase is organized into modules for controllers, estimators, dynamic models, machine learning, and utilities, with a clear base class hierarchy. Key reusable components include symbolic variable management (Vector, RightHandSide), hyperparameter optimization frameworks, kernel composition for GPs, and OPC UA connectivity for industrial control. The project includes extensive documentation, examples, and tests covering chemical reactors, bioreactors, robotics, and automotive applications. While primarily an application library for control engineering, it also incorporates research-oriented features such as stochastic MPC, path following, and hybrid modelling with learned components. The code is licensed under LGPL-3.0 and is actively maintained with CI/CD pipelines and regular releases.
This repository is the Korean translation of the Modern JavaScript Tutorial (https://javascript.info). It contains a comprehensive collection of educational articles, tasks, solutions, and interactive code examples covering core JavaScript, browser APIs, networking, animations, web components, and regular expressions. The content is structured as static markdown files with embedded code snippets and self-contained HTML demos. It is not a production software application but a static educational resource. The repository demonstrates consistent translation conventions and includes reusable teaching patterns such as decorators, custom events, drag-and-drop algorithms, and event delegation. Some content references older browser behaviors and deprecated APIs (e.g., `__proto__`, XMLHttpRequest), but also covers modern features like async/await, Promises, and modules. The code examples are clean and well-documented, making it a valuable learning resource for Korean-speaking developers.
OpenCrew is a multi-agent operating system designed to extend OpenClaw into a manageable AI team. It enables users to create specialized agents (Chief of Staff, CTO, Builder, CIO, Knowledge Officer, Operations, Research) that collaborate through messaging platforms like Slack, Discord, and Feishu. The system implements structured collaboration through role-based channels, thread-based task isolation, and agent-to-agent communication protocols. Key features include autonomy levels (L0-L3), task classification (QAPS), two-mode agent collaboration (delegation and discussion), and three-layer knowledge distillation. The application is actively maintained with recent updates focusing on cross-agent collaboration capabilities.
Attic is a self-hostable Nix binary cache server written in Rust. It provides a remote store for Nix build outputs (NARs, paths) with features like multi-tenancy, global deduplication via content-defined chunking (FastCDC), managed signing, garbage collection, and S3-compatible storage backends. It serves as a modern, open-source alternative to services like Cachix, allowing teams to run their own cache infrastructure. The architecture is a multi-component Rust workspace. The `atticd` server daemon is built on Axum and SeaORM (supporting PostgreSQL and SQLite). The `attic` CLI client handles pushing and querying caches via FFI to `libnixstore`. A shared `attic` library provides core logic for chunking, hashing, and signing, while the `attic-token` crate handles JWT-based access control. The storage layer is abstracted behind a trait, with local filesystem and S3 implementations. The project is under active development but is explicitly an early prototype. It relies heavily on nightly Rust features and pre-release dependencies, resulting in high technical drift. The codebase demonstrates strong engineering craftsmanship in areas like the FastCDC implementation, custom serde for Nix manifests, and clean async stream composition. While the core components are well-abstracted and potentially reusable, the overall system is tightly coupled to the Nix ecosystem and a specific Rust compiler version, making it a high-risk dependency for production use without dedicated maintenance.
city-roads is a browser-based single-page application that fetches OpenStreetMap road data and renders every road in a chosen city as WebGL line art. Users search for a city; the app geocodes the query via Nominatim, suggests administrative boundaries, and then loads data either from a prebuilt protobuf cache hosted on CloudFront/S3 or from the Overpass API. The downloaded OSM nodes and ways are parsed into a Grid object, projected into 2D local coordinates with a Mercator projection, and pushed into a w-gl WireCollection for fast canvas rendering. The UI supports changing road, background, and label colors, editing the city label, saving PNG and SVG exports, and generating Zazzle mug links. A console API exposed as window.scene and window.Query lets advanced users run arbitrary Overpass queries and compose multiple city layers. Architecturally it is a Vue 3/Vite frontend with a clean separation between small lib modules (request, progress, grid, query builders, exporters) and UI components. There is no backend; all data comes from OSM and Nominatim public services plus a static cache. The repository is primarily an application rather than a data-research project, but its lib layer contains genuinely reusable geospatial and Overpass utilities. The codebase is compact, mostly readable, and handles real-world failure modes such as Overpass mirror outages, large downloads, cancellation, and high-resolution exports. Notable weaknesses are the absence of automated tests and CI, leftover Vue CLI configuration, outdated dependencies (Vite 2, Vue 3.2), a debugger statement in App.vue, and a broken custom-projector branch in LoadOptions. Overall it is a solid, functional visualization app with several modular components that could be extracted for other OSM or WebGL projects.
Walrus is a high-performance, topic-based write-ahead log (WAL) storage engine written in Rust, packaged with a distributed message-streaming layer that uses Raft consensus for cluster coordination. The core `walrus-rust` crate provides an append-only log API (`append_for_topic`, `read_next`, batch variants) over a block-based on-disk format: 10MB logical blocks packed into 1GB files, FNV-1a checksums, rkyv-serialized metadata, and a choice of mmap or Linux io_uring (fd) storage backends. Durability is tunable via an `FsyncSchedule` enum (sync-each-entry, periodic millisecond batches, or no-fsync benchmark mode), and reads offer `StrictlyAtOnce` vs `AtLeastOnce` consistency modes. The crate includes crash-recovery logic, rollback/recovery tests, and a regression test for an env-var race condition in WAL construction. The repo also contains `distributed-walrus`, a distributed streaming service that splits topics into ~1M-entry segments, assigns segment leadership round-robin across nodes, and uses a vendored copy of the openraft Raft library for metadata consensus only (topic creation, segment rollover, node membership). Writes are fenced with a Raft-replicated lease so only the current segment leader can append; clients talk to any node over a simple length-prefixed TCP protocol (REGISTER, PUT, GET, STATE, METRICS). The design is formally specified in TLA+ (single-writer-per-segment, no writes past the open segment, sequential write order) and exercised through Docker-based Python harnesses for rollover, stress, resilience, and recovery. A third crate, `octopii`, is a more experimental distributed-WAL prototype using QUIC transport with TLS and a dual-write recovery pattern; its lints are disabled and it contains unfinished paths (`full_snapshot` not implemented), marking it as prototype quality. The strongest engineering sits in the core WAL: the storage layer's shared-mmap keeper (atomic read-lock fast path with write-lock escalation), the background batched fsync worker using io_uring with sync fallback, and the per-topic dirty-tracker with batched rkyv persistence are all cleanly separated, extractable modules. The vendored openraft subtree is essentially a full production-grade Raft library (v0.10.0, edition 2024) contributing high-quality abstractions such as a generic quorum progress tracker, joint-consensus quorum math, an async-runtime abstraction, and three-stage IO flush-progress tracking. However, the repo carries structural debt: `src/wal/` and `octopii/src/wal/wal/` hold near-duplicate WAL implementations that risk drifting; openraft is checked in as a full workspace pinned to nightly-2025-10-01; and several modules rely on process-global state (`WALRUS_DATA_DIR`, global fsync schedule, static tracker maps), which complicates embedding. This is a serious, benchmark-driven storage system (with its own comparisons against Kafka and RocksDB WAL). Engineers will find it most useful as a standalone Rust WAL crate, as a study of a minimal Raft-metadata-plus-local-log sharding design, or as a source of reusable storage primitives. The distributed layer should be treated as a reference implementation rather than production infrastructure, and the `octopii` crate as an exploration.
This repository is a hybrid collection centered around an n8n workflow search engine. The core application is a Python/FastAPI server that indexes and serves ~4,300 n8n workflow JSON files via a SQLite FTS5-backed API, with a static GitHub Pages frontend for browsing. The workflows directory contains a large collection of n8n automation templates covering hundreds of integrations (Slack, Telegram, GitHub, Airtable, etc.), most structured as simple trigger-to-action pipelines. Beyond the main search engine, the repo includes an AI-stack sub-project (Docker Compose for n8n + Agent Zero + ComfyUI), a medical education Next.js app (medcards-ai), Kubernetes/Helm deployment configs, and various utility scripts. The codebase is functional but largely boilerplate — the FastAPI server implements standard CRUD/search patterns with basic security (path traversal protection, rate limiting, CORS), while the workflow JSON files are community-contributed examples of varying complexity. The sub-projects (ai-stack, medcards-ai) appear aspirational rather than production-ready, with the medcards-ai being a well-documented but untested Next.js application.
I‑Simpa is a mature, open‑source desktop application for 3D numerical sound propagation modelling, designed for scientific acoustic simulations. The system provides a full GUI (built with wxWidgets and OpenGL) for defining acoustic scenes (sources, receivers, materials, meshes), running multiple calculation cores (particle tracing SPPS, classical theory TCR, and experimental TLM), and post‑processing results via point/surface receivers, impulse responses, and sound maps. It features a tree‑based data model with XML persistence, a Python scripting layer for automation and custom tools, and supports industry‑standard file formats (STL, PLY, GABE binary arrays). The codebase is predominantly C++ with a Boost.Python bridge, and is actively maintained by the Environmental Acoustic Research unit at Université Gustave‑Eiffel. The architecture follows a classic monolith pattern with clear separation: a core calculation library (`src/spps/`, `src/ctr/`), a 3D rendering engine (`src/isimpa/3dengine/`), a GUI layer (`src/isimpa/IHM/`), and a data manager with element/property tree. Python scripts in `SystemScript/` extend the UI through a plugin mechanism. While the project is functionally complete and validated against benchmarks, it exhibits moderate technical drift: bundled MathJax 2.7.5 (2018) for documentation, some French comments and variable names, and a few Python 2 remnants. Despite this, the component design—especially the octree spatial index, GABE binary I/O, and XML element tree—are cleanly abstracted and potentially reusable in other scientific or simulation contexts. The repository also includes extensive documentation and tutorials, though the experimental directivity feature is flagged as undocumented.
shootback is a reverse TCP tunnel application that enables access to services behind NAT or firewall. It consists of a master server (publicly accessible) and a slaver client (running in the private network). The master listens for slaver connections and client connections, using available slavers to forward client traffic to target services. The architecture uses non-blocking I/O with a socket bridge for efficient data transfer, and a custom control protocol for handshakes and heartbeats. Key components include master.py (main server), slaver.py (client), and common_func.py (shared utilities like SocketBridge and CtrlPkg). The code relies solely on Python's standard library, supporting versions 2.7 and 3.4+. Despite a recent timestamp in metadata, the codebase shows signs of stagnation (e.g., outdated Python version support, lack of recent activity beyond initial development).
ChatClaw is a desktop AI assistant application built with Wails v3 (Go backend + Vue 3 frontend) that provides a local-first, multi-platform AI agent experience. It integrates with multiple messaging platforms (WeChat, QQ, DingTalk, Feishu, WeCom, WhatsApp) through gateway adapters and manages AI agents using the CloudWeGo Eino framework. The application features a knowledge base with full-text search (FTS5) and vector embeddings (sqlite-vec), document processing pipeline (parsing, splitting, RAPTOR hierarchical summarization), scheduled tasks with cron execution, a skill marketplace, MCP tool support, and native desktop capabilities like window snapping, floating ball, and text selection popups. It also bundles an OpenClaw Node.js runtime for advanced agent workflows. The frontend is Vue 3 with TypeScript, Pinia, and shadcn-vue UI components. The architecture is a monolith with service-oriented backend and multiple WebView windows. Note: The repo shows signs of hybridity as it includes substantial data/research components (RAPTOR, embeddings, document processing) but these serve the application's core functionality.