EmuFlight is a real-time embedded flight controller firmware for multirotor drones, forked from Betaflight/Cleanflight. It runs on STM32F4/F7/H7 microcontrollers, providing sensor fusion (gyro, accelerometer, barometer, GPS), PID control, motor mixing, telemetry, and on-screen display. The architecture is bare-metal with a cooperative scheduler, modular driver abstraction (vtable patterns for serial ports, displays, VTX, sensors), and a persistent parameter group (PG) configuration system. Key data flows: sensor inputs → Kalman/dynamic notch filters → PID → mixer → motor outputs; RC input via various protocols; telemetry/blackbox logging output. External dependencies include STM32 HAL, CMSIS DSP, and MAVLink libraries. The codebase is well-structured with unit tests (Google Test) and CI, though it retains some legacy drivers and conditional complexity from the Betaflight lineage.
FloED is a video inpainting system that leverages optical flow guidance to improve temporal consistency and computational efficiency in diffusion-based video generation. The system employs a dual-branch architecture where one branch estimates and refines optical flow between frames, while the main branch performs the actual inpainting guided by flow-adapted features. Key innovations include a training-free latent interpolation method that accelerates denoising through flow warping, and a flow attention cache mechanism that reduces computational overhead when incorporating motion information. The architecture consists of several interconnected components: a RAFT-based optical flow estimator for computing bidirectional flow between frames, a modified UNet3D architecture incorporating temporal modules and flow-guided attention mechanisms, and a pipeline orchestration system that handles the diffusion process. Input video frames and binary masks are processed through a VAE encoder into latent space, where the UNet iteratively denoises the latents conditioned on text prompts, optical flow estimates, and masked latent representations. The decoded output is then blended with the original frames using the masks to produce the final inpainted video. External dependencies include PyTorch-based deep learning libraries (diffusers, transformers), computer vision tools (OpenCV via decord), and utility packages for configuration management and logging. The system is designed for end-to-end video inpainting tasks, taking as input video frames, corresponding binary masks indicating regions to inpaint, and text prompts describing the desired content, producing coherent inpainted video sequences as output.
Seatsurfing is a full-stack, self-hostable desk and room booking system. The backend is a Go application using gorilla/mux, PostgreSQL, Valkey/freecache caching, JWT authentication, and gRPC for a plugin system. The frontend is a Next.js/React TypeScript application with two interfaces: a booking UI and an admin UI. The system manages organizations, locations, spaces, bookings, recurring bookings, public bookings, approval workflows, custom booking attributes, user roles, and granular permissions. It supports multiple authentication methods including password, OAuth2/OIDC, TOTP, and WebAuthn passkeys. The code is structured into repository, service, router, and API layers, with schema upgrades embedded in repositories and a separate plugin host API for extending backend and UI behavior.
Sparnatural is a client-side visual SPARQL query builder implemented as a custom HTML element (`<spar-natural>`). In production, it allows non-technical users to construct complex SPARQL queries by selecting classes, properties, and values through intuitive widgets like autocomplete, list, tree, map, date, number, and boolean. The system is configuration-driven: it loads an ontology (SHACL or OWL) that defines the domain model, widget types, and datasource queries. Queries are built stepwise in a browser using jQuery and Bootstrap-based UI, then translated into SPARQL via two parallel JSON-to-SPARQL translation pipelines (v1 and v13). The generated SPARQL can be sent to a configured endpoint (or multiple endpoints) directly from the browser, and results can be displayed with YASR plugins. The tool also supports query history, faceted browsing, federated queries, and LLM-driven natural language input via a custom prompt pattern. The architecture is modular with clear separation between the UI components (widgets, criteria groups), the specification providers (OWL/SHACL parsers), the state management (event-driven action store), and the SPARQL generators. Key entry points are the custom element attributes (`src`, `endpoint`, `lang`), the `loadQuery()`/`executeSparql()` methods, and the configuration files (`.ttl`). External dependencies include jQuery, Select2, Awesomplete, jsTree, Leaflet, Leaflet-Geoman, Tippy.js, Handlebars, Comunica, N3, sparqljs, and Bootstrap.
Rutie is a Rust library that provides comprehensive bindings to the Ruby C API, enabling bidirectional integration between Rust and Ruby. It allows Rust programs to embed the Ruby VM, create and manipulate Ruby objects, define Ruby classes and modules from Rust, and wrap Rust structs as Ruby objects with garbage collection support. The architecture is layered: `rubysys` contains raw FFI declarations to Ruby's C functions, `binding` provides safe wrappers around those FFI calls, and `class` offers a high-level public API with well-documented types like `Array`, `Hash`, `RString`, `Class`, and `VM`. The library also includes powerful macros (`class!`, `methods!`, `wrappable_struct!`) that simplify defining Ruby-compatible types and methods. It is actively maintained, supports Ruby 2.7 through 3.4, and uses the `rb-sys` crate for modern Ruby compatibility. The codebase is well-structured, extensively documented with examples, and demonstrates advanced FFI patterns, though it acknowledges that some operations are unsafe due to Ruby's exception handling model.
This is an Angular SDK library (`@auth0/auth0-angular`) that integrates Auth0 authentication (OAuth2/OIDC) into Angular single-page applications. It wraps the Promise-based `@auth0/auth0-spa-js` into Angular's reactive ecosystem using RxJS Observables, dependency injection, and Angular Router. The library provides core authentication flows (redirect/popup login, logout, token management), route protection via guards, automatic bearer token injection via HTTP interceptors, and additional features such as MFA, passkeys (WebAuthn), enterprise account linking, custom token exchange, and a MyAccount API client. It supports both traditional NgModule-based and modern standalone (functional) Angular patterns. The playground application included serves as a development and e2e test harness with a local OIDC provider. The architecture is clean, well-tested, and follows Angular best practices, though the core logic is delegated to the underlying Auth0 SPA SDK.
Dynamax is a JAX-native library for probabilistic state space models (SSMs), providing inference (filtering, smoothing, posterior sampling) and learning (EM, SGD, blocked Gibbs) for hidden Markov models (HMMs), linear Gaussian SSMs (LGSSMs), nonlinear Gaussian SSMs (NLGSSMs), generalized Gaussian SSMs (GGSSMs), and switching linear dynamical systems (SLDS). The architecture separates low-level pure functions (e.g., `hmm_filter`, `lgssm_filter`) from high-level object-oriented model classes (e.g., `GaussianHMM`, `LinearGaussianSSM`), all built on JAX for automatic differentiation, vectorization, and GPU/TPU acceleration. The library includes advanced algorithms such as parallel associative-scan filtering/smoothing, information-form Kalman filters, Rao-Blackwellized particle filters, and conditional-moments Gaussian filters (EKF, UKF, GHKF). It is designed for research use, with a focus on numerical correctness and performance, and is accompanied by extensive documentation, tutorials, and a JOSS publication.
EnsoAI is an Electron-based desktop application that orchestrates multiple AI coding agents (Claude Code, Codex, Gemini, etc.) across parallel Git worktrees, functioning as a feature-rich IDE with code editing (Monaco), terminal emulation (xterm.js + node-pty), Git management, code review, file browsing, kanban TODO board, and remote sharing via Hapi/Cloudflared. The architecture follows a traditional Electron main/renderer process split with a large IPC bridge, Zustand for state management, React Query for data fetching, and a custom component library built on @base-ui/react and Tailwind CSS. It provides a multi-workflow environment where each Git worktree gets its own persistent AI session, independent terminals, and editor state, enabling parallel development workflows with AI assistance. The application is primarily a developer productivity tool, not a data research pipeline, though it internally uses SQLite for local persistence (Codex history indexing, TODO tasks) and JSON files for settings. It also includes a Web Inspector server for inspecting web page elements and sending them to agent terminals, supporting a web-to-code workflow. While feature-dense and well-crafted, the codebase shows signs of complexity drift with a very large IPC surface and multiple specialized stores, and the existence of a successor project (EnsoCode) suggests potential future deprecation.
Paperclip is a Rust toolkit for working with OpenAPI specifications. It provides code generation for type-safe HTTP clients and servers from OpenAPI v2/v3 specs, procedural macros to derive OpenAPI annotations from Rust code, and an Actix-web plugin for serving generated specs and integrating with handlers. The architecture is modular with separate crates for core types, macros, Actix integration, and CLI tools. Key features include reference resolution with cycle detection, emitter-based code generation strategy, builder patterns with compile-time field validation, and macro-driven spec generation. The project is actively maintained with recent commits, CI workflows, and frequent version updates.
This repository is a hybrid: it is primarily a curated awesome list for Claude Code resources, but it is backed by a real automation layer that treats the README as a generated artifact. The single source of truth is a CSV resource table plus a config.yaml that defines category ordering; a Python script (generate_readme.py) renders the README, ticker SVGs, and recently-added carousels. The repo also includes GitHub Actions workflows that validate new resource submissions via issue forms, handle maintainer approval/rejection commands, and automatically open PRs to add approved resources. This makes it less of a static list and more of a self-maintaining content pipeline.
This repository is the Azure Enterprise-Scale / Azure Landing Zones reference implementation: a policy-as-code and infrastructure-as-code framework for bootstrapping and governing large Azure environments. It does not run a runtime service; instead it ships deployable ARM templates, Bicep source templates, PowerShell automation, and a large library of custom Azure Policy definitions and initiatives. In production, platform teams use it to create management group hierarchies, assign RBAC roles, deploy policy assignments, provision hub-and-spoke or Virtual WAN network topologies, and standardize subscription landing zones across multiple Azure clouds (AzureCloud, AzureUSGovernment, AzureChinaCloud). The real, code-level deliverable is governance-as-code: hundreds of Deny/Audit/DeployIfNotExists/Modify policies covering security, networking, storage, SQL, containers, key vault, encryption, diagnostics, and cost optimization, plus Pester-based tests that validate policy behavior in live Azure subscriptions.
Valign.el is a single-file Emacs Lisp package that provides pixel-perfect visual alignment for tables in Org mode, Markdown, and table.el on GUI Emacs. It handles variable-pitch fonts, CJK characters, and images without altering the underlying text-based alignment. The core mechanism uses Emacs' display text properties and overlays to stretch spaces to calculated pixel positions, ensuring columns align correctly regardless of font metrics. The architecture is a self-contained module with generic methods (`cl-defmethod`) for different table types (Org, Markdown, table.el). The main entry point is the `valign-mode` minor mode, which hooks into `jit-lock-functions` to automatically realign tables during fontification. It also provides `valign-table` for manual alignment. The package advises several Org and Markdown functions to trigger realignment after edits, outline cycling, or text scaling. Key data flows: On fontification, `valign-region` scans for table delimiters, then for each table it calculates column widths by measuring pixel widths of cell contents, determines column alignment (left/right), and applies display properties to align cells. It also handles separator rows and fancy bar rendering. The package has no external dependencies beyond built-in Emacs libraries (`cl-lib`, `pcase`, `cl-generic`). The code demonstrates strong Emacs Lisp craftsmanship with clear separation of concerns, robust error handling, and performance considerations (e.g., skipping alignment after self-insert commands, limiting table size). It is a well-maintained, production-quality package available on GNU ELPA.
stable-worldmodel is a PyTorch research library and CLI (swm) for world-model-based reinforcement learning. It provides an end-to-end research pipeline: parallel environment rollout and dataset collection (World + EnvPool), multi-backend episodic dataset storage (Lance default, plus HDF5, folder, video, LanceVideo, and LeRobot adapters), offline training of reference world models (LeWM, PLDM, PreJEPA, GCRL, TD-MPC2, Genie), and planning-based evaluation through model-predictive-control solvers (CEM, iCEM, MPPI, predictive sampling, gradient/PGD, Lagrangian). It is a hybrid of a structured software framework and research code: the package ships a CLI, CI workflow, and roughly 50 test files, while scripts/ contains Hydra+Lightning training pipelines, expert SAC/TD-MPC2 collectors, data-collection shards, and visualization notebooks. The core library is cleanly modular. stable_worldmodel/data uses a pluggable format registry to decouple dataset I/O from backends; stable_worldmodel/planning decouples solvers from cost functions via runtime-checkable protocols (Costable, Constrainable, Dynamics, Objective) composed by a ShootingCostEvaluator; stable_worldmodel/envs registers a broad gymnasium environment suite (DMControl, Gymnasium control, Fetch, OGBench, PushT, TwoRoom, Craftax, ALE, RoboCasa) that exposes domain-randomization variation spaces; stable_worldmodel/world orchestrates vectorized rollouts and evaluation; stable_worldmodel/wm holds model implementations and research losses (SIGReg, VCReg, PLDMLoss). Checkpoint utilities save/load with config JSON from local paths or HuggingFace repos, supporting reproducible training runs. Strengths: the format registry, protocol-driven planning composition, extended Gymnasium spaces with init_value/constrain_fn, and the ReplayBuffer's dual Dataset/Writer interface are genuinely reusable components. Tests pin the planner refactor to bitwise parity with the old cost API, and CI runs a substantial suite. Weaknesses: it is research-grade, not production-grade — lewm/module.py and pldm/module.py are near-duplicates, many TODO markers indicate incomplete features, a known Lance wide-column writer bug is pinned xfail unresolved, robocasa.py hardcodes a ~/robocasa asset path, and optional backend dependencies (torchcodec, lancedb, imageio, LeRobot) can silently degrade format support if unavailable.
This is an Obsidian plugin that integrates large language models (LLMs) directly into the note-taking environment. It provides a template-driven text generation system using Handlebars with custom async helpers, supports multiple LLM providers (OpenAI, Anthropic, Google Gemini, Mistral, Ollama, Perplexity, HuggingFace, Together AI, MiniMax, Azure, and custom endpoints), and offers content extraction from PDF, audio, images, YouTube, RSS, and web pages. The plugin includes a community template marketplace, auto-suggest, an overlay toolbar, a playground for testing templates, and extensive Obsidian integration (commands, views, settings, CodeMirror extensions). Architecturally, it is a client-side monolithic plugin that communicates directly with external LLM APIs and the npm registry for package management. The codebase is large (300+ files) and well-organized into providers, extractors, UI components, and services, but it shows some drift due to hard-coded model lists and deprecated provider support (e.g., Google PaLM). The async Handlebars helpers and generic caching utility are highlight components that could be extracted for reuse in other projects.
mesh-sdk-go is a Go SDK for building Rosetta/Mesh API integrations, the blockchain-agnostic API standard originally developed by Coinbase. It ships both sides of the wire: generated OpenAPI HTTP clients (client/), generated server controllers with router wiring (server/), and a set of runtime engines layered on top. The fetcher wraps API calls with exponential-backoff retries, a connection semaphore, and mandatory response validation; the syncer performs concurrent block fetching with reorg detection; the reconciler compares locally computed account balances against live node state; the parser extracts balance changes, groups operations, and matches operation intents; and the constructor module defines transaction-building workflows in a custom DSL (.ros files) executed by a worker/coordinator pipeline. The keys package implements signers for secp256k1 (including BIP-340 Schnorr), secp256r1, ed25519, and Pallas curves. Architecturally this is a library, not a standalone service: host applications implement service interfaces (BlockAPIServicer, AccountAPIServicer, etc.) and either serve HTTP via server.NewRouter or consume a node through client/fetcher. The block/transaction data flow is node → fetcher → asserter validation → syncer → storage (BadgerDB) → reconciler; construction flows in the reverse direction: DSL workflow → worker execution → key signing → broadcast submission. The types/ directory holds roughly 85 auto-generated Rosetta data models, and templates/ plus codegen.sh regenerate client, server, and types from the mesh-specifications OpenAPI spec. Key external dependencies include BadgerDB, btcec, kryptology, and go-ethereum crypto packages. The codebase is professionally structured: 10+ packages, essentially all with table-driven tests, functional-options configuration, error-sentinel patterns, and mockery-generated mocks. Maintenance is active as of late 2026, with CI, dependabot (0 alerts), and regular commit activity. Technical drift is medium: the repo is mid-rebrand from rosetta-sdk-go (internal import paths and RosettaAPIVersion constants still use the old name), BadgerDB v2 is aging, and a zstd dictionary-training step shells out to a system binary. None of this blocks use today, but adopters should expect regeneration friction and naming inconsistencies as the Mesh rebrand completes.
This repository implements a production-grade Service Metadata Publisher (SMP) server for the Peppol and OASIS BDXR eDelivery networks. It manages participant service groups, service metadata (endpoints, processes, document types), business cards, redirects, and participant migrations. The system exposes both a REST API (supporting Peppol SMP 1.x, BDXR 1.0, and BDXR 2.0 formats) and a Bootstrap-based web administration UI for managing all entities. It integrates with an external Service Metadata Locator (SML) for DNS-based participant registration and provides background jobs for SML synchronization, bulk endpoint changes, and import/export of service groups. The architecture is modular and backend-agnostic: core domain logic and interfaces reside in `phoss-smp-backend`, with three pluggable storage backends implemented via SPI — XML file-based (WAL DAO), SQL (JDBC with Flyway migrations supporting PostgreSQL, MySQL, Oracle, SQL Server, DB2), and MongoDB. The web application layer (`phoss-smp-webapp`) provides servlets, REST executors, and UI pages, with backend-specific webapp modules for each storage variant. Security features include HTTP Basic/Bearer token authentication, TOTP two-factor authentication, role-based authorization, audit logging, and CSP headers. The system is designed for high-volume eDelivery networks and includes caching, long-running job management, and extensive functional/integration tests. Key entry points include the REST API handlers (e.g., `APIExecutorServiceGroupPut`, `APIExecutorServiceMetadataGet`), the secure admin UI pages (e.g., `PageSecureServiceGroup`, `PageSecureSMLRegCreate`), and the application lifecycle listeners (`SMPWebAppListener`). External dependencies include the ph-commons/ph-oton framework stack, database drivers, and Peppol identifier libraries. The codebase is actively maintained with version 8.7.0 and demonstrates strong engineering practices including SPI-based extensibility, immutable domain objects, and consistent audit patterns.
svg2jsx is a web application that converts SVG markup into valid JSX code for React components. It provides a real-time editor with a split pane: left for SVG input (with drag-and-drop support) and right for the generated JSX output. The conversion pipeline runs server-side via a Next.js API route, applying SVGO optimization, attribute normalization (camelCase, className, style objects), and optional formatting as a React component (with memo, TypeScript, and quote configuration). The frontend is built with React 18, Next.js 15, TanStack Query, Tailwind CSS, and react-ace for the editor. The codebase is well-structured, with clean separation of concerns between UI components, state management (React Context), and pure conversion logic. Tests cover the core conversion function. The app is designed for single-user, client-side usage with a simple API endpoint.
The numactl repository provides a set of userspace tools and a shared library (libnuma) for controlling Non-Uniform Memory Access (NUMA) memory allocation and CPU binding policies on Linux systems. The core tool, `numactl`, allows launching processes with specified memory placement policies (interleave, bind, preferred, local, weighted interleave) and CPU affinity. The library `libnuma` exposes a C API for applications to set these policies programmatically, interacting with the Linux kernel via system calls (mbind, set_mempolicy, etc.) and reading topology information from sysfs. Additional utilities include `numastat` for per-node memory statistics display, `memhog` for memory allocation testing, `migratepages` for manual page migration, and `numademo` for benchmarking NUMA performance characteristics. The codebase is written in C with autotools build system, maintains API/ABI compatibility through symbol versioning, and includes regression tests and fuzzing harnesses. It is the de facto standard library for NUMA policy management on Linux.
sqlite-net is a lightweight .NET ORM library for SQLite, providing both synchronous and asynchronous APIs. It maps C# classes to database tables via attributes, supports CRUD operations, LINQ-like queries, transactions, migrations, encryption (SQLCipher), and backup. The library is implemented in two main source files (SQLite.cs and SQLiteAsync.cs) and uses SQLitePCLRaw or P/Invoke to interface with native SQLite. It targets .NET Standard 2.0, .NET 8, and .NET 9, and is designed for cross-platform use including Xamarin, UWP, and desktop applications. The codebase is well-structured with performance optimizations like fast column setters and prepared statement caching, and includes a comprehensive test suite. It is actively maintained with recent commits and CI integration.
This repository implements the Adaptive Cards specification, a JSON-based interactive card format developed by Microsoft. The system provides a cross-platform SDK for parsing, rendering, and interacting with adaptive card payloads. The core is a shared C++ object model that defines all card elements (TextBlock, Image, Container, Column, Table, Inputs, Actions, etc.) and handles JSON serialization/deserialization, schema versioning, fallback, and ID collision detection. Platform-specific renderers for Android (Java/SWIG), iOS (Objective-C), .NET (WPF), UWP (C++/WinRT), and Node.js (TypeScript) convert the parsed card model into native UI components. The architecture is a library with multiple language bindings, not a monolithic application. Key entry points include the AdaptiveCard class for parsing, platform-specific renderer classes (AdaptiveCardRenderer), and registration systems for custom elements/actions. The system also includes a designer tool (Node.js) for visually editing cards, a templating engine (ANTLR-based) for dynamic card generation, and a markdown rendering pipeline (MarkedNet). External dependencies include JSON libraries (Newtonsoft.Json, etc.), markdown parsers (MarkedNet, markdown-it), SWIG for Java bindings, and ANTLR for templating. The codebase demonstrates strong engineering practices with clean abstractions (parser registration, renderer registration, host config), extensive unit and integration tests across platforms, and a consistent fallback mechanism. However, it shows signs of technical drift: multiple platform implementations may diverge in behavior, auto-generated SWIG code requires careful synchronization, and some deprecated properties and commented-out tests indicate legacy cruft. The project is actively maintained with CI pipelines and recent commits.