This repository provides a Lean 4 tactic `smt` that automates theorem proving by delegating goals to the cvc5 SMT solver and reconstructing the resulting proof in Lean. It supports a range of theories including uninterpreted functions, linear integer and real arithmetic, bitvectors, strings, and quantifiers. The codebase is organized into preprocessing (normalization, monomorphization, embedding), translation to SMT-LIB, solver communication, and proof reconstruction for each theory. The project is in beta but actively developed, with extensive test coverage across supported domains. While the primary interface is a tactic, the architecture reveals multiple reusable components such as an S-expression DSL, SMT term representation, graph data structure, and a configurable WHNF reduction engine. The main entry point is `Smt/Tactic/Smt.lean`, and the library is distributed as a Lean package. The code is tightly integrated with the cvc5 FFI and Lean's metaprogramming infrastructure, making it primarily a library rather than a standalone application, but it fits the 'application' category as a tool for interactive theorem proving.
mockturtle is a header-only C++17 library for logic network synthesis and optimization. It provides a generic framework for multiple logic network representations (AIG, MIG, XAG, XMG, k-LUT, etc.) and a wide range of algorithms including cut enumeration, rewriting, balancing, resubstitution, decomposition, technology mapping, and equivalence checking. The library uses template metaprogramming and static polymorphism to achieve flexibility and performance, with a decorator pattern for views that add functionality (depth, fanout, mapping) without modifying base networks. Bundled external libraries (kitty, lorina, percy, bill) handle truth tables, file parsing, exact synthesis, and SAT solving. The codebase is well-tested (Catch2) and includes experimental research flows for emerging technologies like AQFP superconducting logic.
Ibis is a federated wiki platform built entirely in Rust, enabling users to create, edit, and discuss articles across ActivityPub-enabled instances. The application follows a full-stack architecture with a Leptos-based frontend (compiled to WASM for client-side hydration) and an Axum backend serving both the API and server-side rendering. PostgreSQL is used as the database via Diesel ORM, and federation is implemented using the `activitypub-federation` crate, allowing articles, edits, comments, and user profiles to be synchronized between independent instances. The codebase is organized as a Cargo workspace with separate crates for backend, frontend, federation logic, database access, API client, markdown rendering, and reusable UI components. Key features include markdown-based article editing with custom extensions (LaTeX, table of contents, article links), edit conflict resolution via three-way merge, user authentication (JWT, OAuth, email verification), in-app and email notifications, and Wikipedia article import. The frontend uses Tailwind CSS with DaisyUI components and supports internationalization via `leptos-fluent`. Ibis demonstrates strong software engineering practices: modular crate structure, comprehensive integration tests with multi-instance federation scenarios, CI pipeline with formatting and linting, and Docker-based deployment. While the codebase is actively maintained and well-architected, it contains some production `expect` calls and relies on beta versions of key dependencies, which introduces minor risk. Overall, it is a polished, production-ready federated application with reusable patterns in frontend components, database abstractions, and ActivityPub object handling.
This repository provides a high-performance surface reconstruction system for SPH (Smoothed Particle Hydrodynamics) fluid simulation data. The core library, splashsurf_lib, implements a marching cubes pipeline that converts particle positions and densities into triangle meshes, with subdomain-based parallel decomposition, SIMD-accelerated kernel evaluation (AVX2, NEON), and optional post-processing (weighted Laplacian smoothing, barnacle decimation, quad conversion, attribute interpolation). The system is exposed as a CLI tool (splashsurf), a Python package (pysplashsurf via PyO3), and a Blender add-on (splashsurf_studio) for interactive viewport and render-time reconstruction. The architecture is modular: a generic library with traits for numeric types, a dense subdomain grid for parallelism, a half-edge mesh for decimation, and a custom nom-based BGEO parser. The codebase is well-structured with strong emphasis on performance and reproducibility, and it implements the research from Löschner et al. (2023) on weighted Laplacian smoothing. It targets researchers and artists working with SPH simulations (e.g., SPlisHSPlasH) and supports multiple input/output formats (VTK, PLY, OBJ, BGEO, XYZ, JSON).
Tunet is a modern, responsive React dashboard for Home Assistant that provides a customizable interface for monitoring and controlling smart home entities. The application features a React/Vite frontend with an Express/Node.js backend, using SQLite for persistent storage of user configurations. It implements a modular card-based UI system with 20+ specialized card types (lights, climate, media, etc.), real-time WebSocket synchronization with Home Assistant, and extensive customization options including theming, layout configuration, and plugin-like extensibility. The application follows React best practices with custom hooks, context API for state management, and a well-organized component architecture.
Luet is a container-native package manager for building, installing, and managing software packages. It uses Docker/buildah as build backends, treats packages as container images, and employs SAT solving (with optional Q-learning) for dependency resolution. The application features a CLI-driven architecture with commands for package operations, repository management, and system maintenance. Key architectural elements include a modular design with pluggable solvers, compiler backends, and repository clients, plus a context-based dependency injection system for logging, configuration, and garbage collection. The system stores package metadata in BoltDB or in-memory databases and supports templating via Sprig for dynamic package definitions.
AutoHarness is a CLI-driven application for automated benchmark harness optimization. It implements an iterative workflow where proposals (code/config changes) are generated via LLMs or templates, applied to a target harness, evaluated using benchmark adapters (Tau2/Bench, HAL, Harbor, etc.), and promoted based on statistical validation. The system manages workspaces, tracks, campaigns, and iterations with persistent state stored under .autoharness/. Key features include proposal generators (Codex/Claude assistants, OpenAI Responses, failure-driven), benchmark adapters with staging isolation, configuration composition, and extensible plugin architecture for search strategies and preflight checks. The tool supports both interactive and non-interactive modes with configurable autonomy levels (proposal/bounded/full) and provides comprehensive inspection/export capabilities for auditability.
bevy_light_2d is a Rust library providing 2D lighting functionality for the Bevy game engine. It implements point lights, spot lights, light occlusion (shadows), and ambient lighting through a multi-pass rendering system using signed distance fields (SDF) and ray marching. The architecture follows Bevy's ECS pattern with a plugin that integrates into the render graph, separating extraction, preparation, and rendering phases. The library demonstrates solid software engineering practices with clear separation of concerns and implements non-obvious graphics techniques for efficient shadow calculation.
Telemirror is a Telegram message mirroring application that uses the client API (Telethon) to forward messages between channels, chats, and topics in real-time. It supports one-to-one, many-to-one, and many-to-many mappings with per-direction filter pipelines. The system handles new messages, edits, deletions, and albums, and can operate with either an in-memory cache (backed by an LRU dict) or a PostgreSQL database for persisting message ID mappings. It includes a plugin-based filter system for message transformation (URL removal, keyword replacement, forward formatting, content skipping) and patches Telethon's sending functions to support topic replies. The application is designed to run as a long-lived service with a health endpoint for PaaS deployment (Heroku, Docker). The codebase is well-structured with clean separation of concerns, async-first design, and modern Python features (dataclasses, protocols, enums, pattern matching).
This repository provides Rust bindings to Apple's Security.framework, enabling safe access to Keychain services and TLS/SSL functionality. It consists of a safe wrapper crate (`security-framework`) built upon raw FFI bindings (`security-framework-sys`), with platform-specific implementations for macOS. The library employs idiomatic Rust patterns such as the builder pattern for configuration, Core Foundation type wrappers for automatic memory management, and zero-cost abstractions using `PhantomData`. Examples demonstrate TLS client connections and Keychain password operations. The architecture separates unsafe FFI bindings (generated via `ctest2` from Apple headers) from safe abstractions. Key components include Keychain item management (search/add/update/delete), SSL/TLS client/server contexts, certificate handling, and cryptographic transforms. The project is actively maintained with recent commits, includes test harnesses for iOS and system validation, and shows awareness of API evolution through deprecation markers.
JSPrintManager is a client-side printing and scanning solution enabling web applications to bypass browser print dialogs by communicating with a native client application via WebSocket. The system consists of a core JavaScript library (JSPrintManager.js) that provides APIs for creating print/scan jobs, managing printer connections, and handling device-specific communication protocols (serial, USB, Bluetooth, TCP/IP, HID, IPP). A React-based demo application showcases features including printing various file formats (PDF, images, Office documents), raw printer command languages (ZPL, ESC/POS), bidirectional device communication, printer monitoring, and scanning functionality. The solution requires installation of a lightweight native client on user machines to establish the WebSocket bridge between browser and hardware devices.
This repository powers the tina.io website: a marketing, blog, changelog, and documentation hub for TinaCMS (an open-source Git-backed headless CMS). Built with Next.js 14 (App Router), TypeScript, Tailwind CSS, and TinaCMS itself as the content management system, it dogfoods the product. Content is stored as JSON (structured pages with block-based templates) and MDX (blog posts with rich components). The site features internationalization (English/Chinese with automated translation workflows), Algolia search indexing, API routes for Mailchimp, SendGrid, GitHub, and YouTube integrations, OG image generation via Satori/resvg, visual regression testing with Playwright, and a comprehensive UI component library. The architecture is a standard Next.js monolith with a block-based page builder and a custom TinaCMS schema defining 12 content collections. While the codebase is well-organized and actively maintained, it exhibits some technical debt: mixed styling systems (styled-components and Tailwind), TypeScript strict mode disabled, and a large block template set that may become unwieldy. The i18n implementation relies on duplicated route trees, which a design document aims to refactor.
matplot2tikz is a Python library that converts matplotlib figures into PGFPlots/TikZ code for native inclusion in LaTeX or ConTeXt documents. It recursively traverses a matplotlib Figure tree, translating each artist (lines, patches, images, colorbars, legends, text, etc.) into corresponding PGFPlots commands. The library provides two main entry points: `get_tikz_code()` returns the TikZ code as a string, and `save()` writes it to a file. It also includes a `clean_figure()` function that simplifies paths and reduces data points to minimize output size while preserving visual fidelity. The architecture is modular, with dedicated modules for each artist type (e.g., `_line2d.py`, `_patch.py`, `_axes.py`), a central data class (`TikzData`) to carry configuration and state, and a recursive traversal in `_save.py`. External dependencies include matplotlib, numpy, Pillow, and webcolors. The codebase is well-tested with over 170 test files and uses modern Python tooling (ruff, mypy, tox). It is a fork of the unmaintained tikzplotlib and is actively maintained with recent commits and CI.
Smudgeplot is a bioinformatics CLI tool for reference-free ploidy inference from whole genome sequencing data. It operates on FastK k-mer databases, identifying heterozygous k-mer pairs (hetmers) using a high-performance C backend, then aggregates them into 'smudges' via a local clustering algorithm in Python. The tool infers haploid coverage through a grid search and produces 2D histogram plots (smudgeplots) that reveal haplotype structure. The codebase is a hybrid of a Python package (command-line interface, data analysis, matplotlib-based visualization) and a custom C library (parallelized k-mer pair detection). It follows a clean architecture with well-separated concerns, a comprehensive CLI, and CI/CD pipelines for distribution. The project is actively maintained, with recent support for Python 3.14 and cross-platform wheel builds.
This repository is a Java library for industrial communication protocols, providing implementations for Siemens S7 PLC, Modbus, Mitsubishi Melsec, RTSP/RTP/RTCP media streaming, and MP4 file format handling. The library features a modular architecture with clear separation by protocol, annotation-based serialization frameworks, and low-level utilities for binary data handling. It serves as an SDK for developers to integrate industrial device communication and media streaming capabilities into their applications. The code demonstrates consistent use of design patterns (builder, template method, annotation-based processing) and includes comprehensive test suites showing usage patterns.
hyper-sdk is a high-level JavaScript SDK for the Hypercore Protocol ecosystem, providing a unified API to create and manage Hypercore, Hyperdrive, and Hyperbee instances with automatic peer discovery via Hyperswarm. It abstracts away the complexity of lower-level modules (corestore, hyperswarm, hypercore, hyperdrive, hyperbee) and offers features like DNS resolution for hyper:// URLs, persistent storage via RocksDB, and lifecycle management (suspend/resume). The SDK is designed for cross-platform use (Node.js, Electron, Pear) and includes comprehensive TypeScript type definitions. The codebase is well-structured, uses modern ES module syntax, private fields, and has a thorough test suite covering storage reuse, key/name/URL resolution, DNS caching, and peer-to-peer replication. It is actively maintained with up-to-date dependencies and zero security alerts.
The reactjs/ja.react.dev repository is the official Japanese translation of the React documentation site (react.dev). It is a Next.js (Pages Router) application that compiles MDX content into static pages with dynamic interactive features. The architecture uses Next.js for static generation, with custom React components (MDX, Layout, Icons), a sophisticated Sandpack integration for live code playgrounds (including a custom React Server Components sandbox inside an iframe), Algolia DocSearch, Tailwind CSS styling, and textlint for Japanese proofreading. Key entry points include the catch-all page `src/pages/[[...markdownPath]].js` that renders all documentation, and the API route `src/pages/api/md/[...path].ts` for serving raw markdown. The site also generates RSS feeds, runs a dead link checker, and uses custom ESLint rules to lint React code blocks within markdown. External dependencies include React 19, Next.js 15, Sandpack, MDX, and various remark/rehype plugins. While the codebase is well-organized and demonstrates strong engineering practices (TypeScript, custom tooling, CI/CD), its components are tightly coupled to the documentation site's layout and content structure, limiting direct reuse outside of similar documentation projects.
This repository provides a collection of custom nodes for ComfyUI and SD WebUI (reForge) that implement various guidance techniques for diffusion models. It includes implementations of Perturbed-Attention Guidance (PAG), Smoothed Energy Guidance (SEG), Sliding Window Guidance (SWG), PLADIS, Normalized Attention Guidance (NAG), Token Perturbation Guidance (TPG), Frequency-Decoupled Guidance (FDG), Momentum Guidance (MG), and Sliding Mode Control CFG (SMC-CFG). The architecture consists of modular node files, shared utility functions, and backend compatibility layers. Key entry points are the ComfyUI extension registration in __init__.py and the reForge integration scripts in the scripts directory. The system modifies the denoising process of diffusion models by injecting guidance computations at specific U-Net blocks, enhancing image quality and control.
ember-sortable is an Ember.js addon providing sortable UI primitives for drag-and-drop reordering of lists, grids, and tables. It implements modifiers (sortable-group, sortable-item, sortable-handle) that attach drag-and-drop behavior to DOM elements, with built-in support for mouse, touch, and keyboard input. The architecture centers around a service (ember-sortable-internal-state) that manages state between sortable groups and items, enabling features like visual feedback during drag, automatic container scrolling, and accessibility support including screen reader announcements and keyboard navigation. The library follows Ember addon conventions with a modular structure, clear separation of concerns, and comprehensive test coverage.
Aerugo is a safety-critical real-time operating system (RTOS) for embedded systems, specifically targeting the ARM Cortex-M7 (ATSAMV71) microcontroller. Developed under an ESA contract for space applications, it provides a non-preemptive, cooperative scheduler based on fine-grained tasklets, along with event-driven and cyclic execution, message queues, boolean conditions, and execution monitoring. The system is designed for static allocation, no dynamic memory, and no_std environments. The repository includes a full hardware abstraction layer (HAL) for the SAMV71, covering SPI, UART, PIO, timers, watchdog, XDMAC, PMC, FPU, and more, built on top of an auto-generated peripheral access crate (PAC) from the vendor SVD. A custom Python test framework (calldwell) enables hardware-in-the-loop testing via RTT, GDB, and SSH, with formal requirements traceability embedded in test code. The architecture is modular: the core RTOS kernel resides in `src/`, platform-specific code in `arch/` (Cortex-M and x86), and reusable utilities in `utils/` (bitfield-enum macro, bounded integers, LSM6DSO IMU driver). The HAL uses typestate patterns to enforce correct driver configuration at compile time. The codebase demonstrates strong Rust embedded engineering practices, including manual vtables for type erasure, critical-section-based mutexes, and static resource management via OnceCell. However, it relies on nightly Rust features (const_mut_refs, proc_macro_tracked_env) and the PAC is auto-generated, introducing maintenance risks. The project is actively developed with a comprehensive test suite and real-world demos (e.g., SPI accelerometer with CCSDS telemetry).