This repository implements a personal link-in-bio web application (moure.dev) built with Reflex, a Python web framework that compiles to a React frontend with a FastAPI backend. The application serves as a central hub for Brais Moure's social media profiles, programming courses, newsletter subscription, and sponsor showcases. It features two main pages: an index page with social links and a courses page listing educational resources. The architecture follows a modular pattern with separate components for UI elements (buttons, icons, headers, footers), a state management class for asynchronous data fetching, and a FastAPI sub-app that exposes REST endpoints for live Twitch status, featured content from Supabase, and event schedules from ConfigCat feature flags. The frontend is rendered using Radix UI primitives and includes client-side theming, analytics tracking (Google Analytics, Facebook Pixel), and a newsletter integration via Beehiiv. The codebase is primarily educational, accompanying a 13-hour video course on web development with Python. It demonstrates how to build a full-stack application using Reflex, integrate external APIs (Twitch, Supabase, ConfigCat), manage application state, and deploy via Docker or static export. The project includes CI/CD via GitHub Actions for automated static builds. While the application is functional and well-structured for its scope, it lacks automated tests and contains some commented-out code. The generated frontend assets are tightly coupled to specific Reflex and React versions, posing potential maintenance challenges during upgrades. External dependencies on Twitch, Supabase, and ConfigCat require valid credentials via environment variables, limiting out-of-the-box reproducibility.
This repository is a community-driven curated list of Vim9script plugins, utilities, and libraries, hosted primarily on GitHub and Codeberg. Its main output is a generated README.md table that organizes contributions by category with descriptions and star counts. While the heart is the list itself, the repository includes a reusable Python script (`scripts/update_readme.py`) that reads a flat list of repository URLs from `contributions.md`, fetches metadata (description, star count) from the GitHub and Codeberg APIs, sorts and formats the data, and rewrites both `contributions.md` and `README.md`. The script also tracks star milestones and logs them to `congratulations.md`. The architecture is a single-purpose CLI utility. Despite being primarily a directory, the automation script qualifies it as an application with a hybrid nature.
This repository contains the ESP-Drone firmware, an open-source flight control system for quadcopters based on Espressif ESP32/ESP32-S2/ESP32-S3 microcontrollers. It is a port of the Bitcraze Crazyflie firmware (GPLv3) and is primarily designed for STEAM education. The system provides a complete drone control stack including sensor drivers (IMU, barometer, magnetometer, ToF range finders, optical flow), state estimation (complementary filter, extended Kalman filter), attitude/position controllers (PID, Mellinger, INDI), and communication via Wi-Fi (UDP, ESP-NOW) and CRTP protocol. It supports modular expansion 'decks' for additional hardware like flow sensors, thermal cameras, and localization systems (Lighthouse V1/V2, UWB TDoA). The firmware runs on FreeRTOS and uses ESP-IDF v5.0 as its development framework.
This repository is a collection of AWS EC2 Spot Instance best practices and workshop examples. It contains diverse implementations showing how to use Spot Instances across various AWS services including EC2 Auto Scaling, EC2 Fleet, ECS, EKS, Lambda, SageMaker, AWS Batch, and EMR. The examples demonstrate patterns for handling Spot Instance interruptions, cost optimization, fault tolerance, and workload-specific optimizations. While not a single cohesive application, it serves as a practical reference for deploying cost-effective, interruption-resilient workloads on AWS Spot Instances.
Strengths include clear package separation, a facade around the segmentation pipeline, a command-pattern undo system, and a few isolated utilities such as native memory cleanup and PAGE XML type conversion. Weaknesses are limited test coverage (one test class), heavy global state in the frontend controller, outdated dependencies (Spring 5.2, jQuery 3.4, Paper.js 0.12), reflection-based helpers, and some brittle JSP/tag-file UI code. It remains a functional tool but would need modernization and stronger testing to be considered a reference-grade codebase.
Edzelf/ESP32Radio-V2 is an internet radio receiver firmware for the ESP32 microcontroller. It streams audio from Shoutcast/Icecast servers and plays local MP3 files from an SD card. The system supports both hardware (VS1053) and software (Helix MP3/AAC) audio decoding, with output via I2S DAC, internal DAC, or Toslink optical. It offers a web-based interface for station selection, volume control, and configuration, as well as MQTT, IR remote, and rotary encoder inputs. The firmware is built with PlatformIO and the Arduino framework, and it is designed to be highly configurable through compile-time defines in a central `config.h` file. Architecturally, the application is monolithic, with all main logic concentrated in a single `main.cpp` file. It uses multiple FreeRTOS tasks for networking (HTTP streaming), audio decoding/output, and SD card operations, communicating via FreeRTOS queues. A custom state machine handles HTTP streaming and metadata extraction. The system abstracts display hardware (various TFT, OLED, and LCD types) through a set of driver libraries with consistent interface macros, allowing the same firmware to be compiled for different display modules with minimal code changes. Audio decoders are also abstracted via macros, enabling compile-time selection between VS1053 and Helix software decoding. The codebase is actively maintained (last commit Feb 2026), but shows some signs of technical drift: it uses the deprecated SPIFFS filesystem, has version-guarded but older I2S API calls, and relies heavily on conditional compilation which complicates testing and maintenance. The library includes several well-crafted standalone components, such as the display drivers and hardware codec driver (VS1053), which can be reused in other ESP32 audio projects. The Helix MP3 and AAC decoders are large monolithic files with global state, limiting their reusability outside this specific project context.
This repository is a curated 'awesome list' of resources related to status badges, maintained by the Shields core team. It is not a software application or data pipeline; it is a markdown file (README.md) that catalogs dynamic badge services, badge tools, static badge collections, badge-rendering software, icons, academic articles, and more. The repository includes configuration for automated link checking via GitHub Actions and Dependabot for dependency updates. While it contains no application code, it serves as a community-maintained directory for badge-related projects and is actively kept up-to-date with regular link checks and contributions.
AutoTrain Advanced is a no-code / low-code machine learning training platform from Hugging Face, providing a unified CLI, web UI (FastAPI + Jinja2), and REST API to fine-tune models on 15+ tasks including LLM SFT/DPO/ORPO, text/image classification, object detection, token classification, seq2seq, sentence transformers, and VLM. It wraps the Hugging Face ecosystem (transformers, datasets, peft, accelerate, trl) and supports multiple backends: local GPU, Hugging Face Spaces, NVIDIA NGC, and NVCF. The project is officially deprecated as of late 2024, with the README explicitly stating no new features will be added and recommending alternatives. The codebase is architecturally well-organized with a modular trainer structure, Pydantic parameter models, abstract backend patterns, and reusable callbacks, but suffers from duplicated dataset loading logic, heavy coupling to Hugging Face API, and a sprawling single-file UI. It remains functional for users who need a turnkey fine-tuning solution with existing dependencies, but is not suitable for new projects requiring long-term maintenance.
This repository is a comprehensive Flutter learning project that simulates an e-commerce management system (merchant order, goods, statistics, shop settings, account/withdrawal). It showcases a wide array of Flutter techniques: MVP architecture with a base presenter pattern, provider state management, custom animations (Lottie, ripple, scratch card), custom chart widgets (bezier and pie charts), complex scrolling (NestedScrollView, custom scroll view), dark mode, localization (English/Chinese), QR code scanning, image picking, AMap integration, and more. The application contains multiple modules connected via fluro routing, with Dio for networking (targeting a mock GitHub API). While the codebase demonstrates many patterns and includes a significant test suite (unit, integration, accessibility), it is primarily a personal learning project and contains several signs of incomplete migration, mock-only behaviors, workarounds, and copied/vendored code. As such, it serves as a rich educational reference for Flutter development but is not production-ready without refinement.
Vizra ADK is a retired Laravel package (final release v0.0.48) that provides a comprehensive framework for building AI agents with LLM orchestration, tool systems, memory, workflows, evaluations, tracing, and MCP integration. It is not a standalone application but a library designed to be installed into Laravel projects. The architecture follows Laravel package conventions: service providers, facades (Agent, Workflow), Eloquent models, Artisan commands, Livewire components, and database migrations. Key entry points include the Agent facade for running agents, the Workflow facade for orchestrating multi-agent workflows, and a set of CLI generators for scaffolding agents, tools, and evaluations. The system supports multiple LLM providers via Prism PHP, persistent memory (session, user, vector), tool chaining, sub-agent delegation, and an evaluation framework with LLM-as-a-Judge assertions. The codebase is well-structured with strong test coverage (Pest + Mockery), but the package is officially retired with no further development, leading to high technical drift as dependencies age out. Despite retirement, many components (e.g., ToolChain, VersionablePrompts, AgentVectorProxy, HasLogging) are self-contained and demonstrate reusable patterns suitable for extraction into new projects.
Facad1ng is a command-line URL masking tool designed for security research and phishing awareness training. It takes three inputs: an original URL, a custom domain, and phishing keywords, then generates masked URLs by shortening the original URL via services like TinyURL and embedding it in a deceptive format (e.g., https://[email protected]/path). The tool demonstrates how attackers obfuscate malicious links to aid defensive security training. The core functionality is implemented in Python with input validation, multiple shortener support, and a user-friendly interface featuring ASCII art and animated loading screens.
You-Get is a command-line media downloader supporting over 80 websites (YouTube, Bilibili, Youku, TikTok, Instagram, etc.). It uses a plugin-based architecture where each site has a dedicated extractor module that scrapes or API-crawls for media URLs, downloads segments, and optionally merges them using ffmpeg or pure-Python fallbacks. The core library in `common.py` provides HTTP utilities, progress bars, cookie loading, and merging logic. While the extractor pattern is clean and extensible, code quality varies across the many extractors, some of which use brittle regexes or deprecated helper functions. The project has a moderate test suite covering only core utilities and a few extractors, and relies on external tools like ffmpeg and dukpy (for YouTube signature deobfuscation). Overall, it is a functional, widely-used tool with some reusable infrastructure components but significant technical debt from site-specific scraping logic.
Polynote is a polyglot notebook server that enables interactive data analysis in Scala, Python, SQL, and Vega. It provides a web-based IDE with Monaco editor, real-time kernel execution, rich visualizations (Vega-Lite, Matplotlib), and tight Apache Spark integration. The architecture is a monolith: a Scala server using ZIO effects, a custom binary WebSocket protocol, and a TypeScript frontend with its own reactive state management. Key entry points are the server main class (Main.scala) and the headless notebook runner (NotebookRunner.scala). Data flows from cell edits through WebSocket messages to the kernel, which executes code and streams results back. External dependencies include JVM, Python via Jep, Spark, Coursier for dependency resolution, and various frontend libraries. While primarily an application, it also serves as a data exploration platform with streaming data abstractions and visualization capabilities.
This repository is the official Spring Boot getting started guide (gs-spring-boot). It provides a minimal web application that demonstrates Spring Boot's auto-configuration, embedded Tomcat, and actuator endpoints. The codebase consists of a single REST controller returning a static greeting string, a Spring Boot application class with a CommandLineRunner that lists all beans, and corresponding unit and integration tests. The complete variant includes Spring Boot Actuator for production-ready features. The repo serves purely as a tutorial scaffold, not a production-grade application. The architecture is a trivial monolith with no external services, database, or complex data flow. All source files are framework boilerplate generated or inspired by Spring Initializr. There are no reusable components or non-obvious patterns. The value lies in its documentation and as a starting point for learning Spring Boot. Despite its simplicity, the repository is actively maintained with up-to-date dependencies (Spring Boot 4.0.x, Kotlin 2.2.x, Gradle 9.3.x) and CI pipelines. It includes both Java and Kotlin implementations, and both Maven and Gradle build systems.
Daijin is a container management tool designed for Android devices running Termux. It provides a menu-driven interface to create, run, remove, and manage Linux containers using either the ruri backend (a lightweight container implementation) or proot (a chroot alternative). The application orchestrates container lifecycle operations by integrating with submodules rurima (for running Docker/LXC images without Docker/LXC) and rootfstool (for obtaining container rootfs from mirrors). Key functionalities include downloading container images, setting up container environments with proper permissions and networking, managing container configurations, and providing launch mechanisms. The architecture is monolithic with modular shell scripts handling specific operations, all built as a Debian package for Termux deployment.
This repository is the official home of the WAMP (Web Application Messaging Protocol) specification, a routed protocol for publish-subscribe and remote procedure calls (RPC) that runs over WebSocket and other transports. It defines the protocol through RFC-style markdown documents (basic and advanced profiles) with detailed message formats, session state machines, authentication schemes (WAMP-CRA, WAMP-Cryptosign, SCRAM, ticket), transport options (RawSocket, batched WebSocket, long-poll), and advanced features like event history, payload passthru mode for E2E encryption, and router-to-router links. The repository also includes a conformance test suite (testsuite/) with machine-readable JSON test vectors covering single messages, sessions, and multi-session scenarios across multiple serializers (JSON, MessagePack, CBOR, UBJSON/BJData, FlatBuffers), along with validation scripts and generators. Additional assets include a catalog of standard WAMP interfaces defined in FlatBuffers IDL (catalog/), governance documents for the WAMP DAO and Swiss association (dao/), and a series of WAMP Enhancement Proposals (WEPs) for future extensions. The codebase is primarily a specification and test infrastructure, not a runnable application. It enforces an AI-assistance disclosure process for contributions (via .audit/) and uses a modern build system with just and uv for generating spec PDFs, documentation, and running tests. The test vector schema (SCHEMA.json) is a standout reusable component: it defines a structured format for message samples, per-serializer byte representations, expected attributes, and per-implementation validation code, enabling cross-language conformance testing. While the specification is comprehensive and the test suite well-organized, many sections remain incomplete (marked 'Write me.', TBD, or 'sketch/alpha'), and there are duplicated working documents in _work/ and binary file artifacts (Visio, OpenDocument) that are hard to review and at risk of drift. The repository shows active maintenance with recent commits and CI workflows, but the unfinished parts and legacy assets lower the overall quality to average.
This repository is a comprehensive collection of sample applications for the Microsoft Windows App SDK (WinUI 3). It demonstrates a wide range of platform features including app lifecycle management (activation, instancing, restart, state notifications), scene graph composition (animations, effects, lighting with ExpressionBuilder), notifications (toast, push), widgets, windowing (custom title bars, multi-window), deployment (packaged/unpackaged, self-contained), Windows AI/ML (ONNX inference, AI Foundry APIs like image captioning and text rewriting), text rendering (DWriteCore), printing, camera capture, custom controls, and XAML Islands interop with WinForms/WPF. The samples are provided in multiple languages (C# and C++/WinRT) and target various app models (WinUI 3, WPF, WinForms, console). The codebase is primarily educational—serving as reference implementations—rather than a production library. It suffers from heavy copy-paste duplication across language/framework variants, hardcoded version numbers, and occasional stale references, but includes a few genuinely reusable components such as the ExpressionBuilder fluent animation library and the ImageLoader async surface management system.
This repository is a mobile SDK for real-time interactive AI avatars, primarily targeting Android and iOS platforms. It provides on-device inference for speech recognition (via WeNet) and face/body segmentation (via ncnn-based U-Net models), enabling low-latency lip-sync and avatar animation driven by audio input. The SDK is structured as a C++ core with platform-specific wrappers (Java for Android, Objective-C for iOS), and includes bundled third-party libraries (ncnn, OpenCV, FFmpeg, ONNX Runtime) for computer vision, audio processing, and neural network inference. In production, the system ingests 16kHz PCM audio from a microphone, extracts MFCC features, runs streaming speech recognition, and simultaneously processes the audio through a U-Net model to generate facial animation frames. These frames are rendered using OpenGL ES (Android) or Metal (iOS) with alpha blending for compositing onto a background. The SDK also includes model download, encryption (AES-128-CBC), and resource management utilities. The architecture is monolithic: all core logic lives in a single C++ module (duix-sdk), with platform-specific integration code in the app directories. The demo app in Android provides a fully functional test harness. While the SDK is feature-complete and demonstrates significant engineering effort in mobile AI inference, the codebase exhibits several quality issues: duplicated third-party headers across architectures, hardcoded encryption keys, outdated library versions (OpenCV 4.6.0, ncnn 2022/2023), and minimal inline documentation. The high star count and fork activity suggest a strong community, but the code itself is functional rather than exemplar. The most reusable components are the reference-counted memory allocator (dh_mem.h) and the AES stream decryption wrapper (gaes_stream.h), which can be extracted for general-purpose use.
This repository provides a full-stack demonstration of a permission management system using Spring Boot for the backend and Vue.js for the frontend. Despite its name, it does not use Apache Shiro; instead, it implements a custom, annotation-based permission control via AOP (RequiresPermissions annotation and PermissionAspect) and token-based authentication using Caffeine local cache. The backend is a monolithic Spring Boot 2.3.10 application with MyBatis for database access, serving a REST API. The frontend is a Vue 2 application (based on vueAdmin-template) with dynamic routing and ElementUI, featuring a custom directive for button-level permission checks. The system supports multi-role users, role-based menu and permission assignment, and a clean separation of concerns between backend and frontend permission enforcement. The codebase is well-structured and serves as a clear reference for implementing RBAC-like permission systems in Java+Vue projects, though it is not intended for production use without significant hardening and updates.
This repository is a lightweight, reference implementation of several standard LLM benchmarks (MMLU, GPQA, MATH, HumanEval, DROP, MGSM, SimpleQA, BrowseComp, HealthBench) developed by OpenAI. It provides a unified evaluation framework based on an `Eval` base class and `SamplerBase` that supports OpenAI Chat Completions API, Anthropic Claude API, OpenAI Responses API, and reasoning models (o1, o3, o4-mini). The main entry point is `simple_evals.py` which accepts command-line arguments to select models and evals, runs them, and outputs HTML reports and JSON metrics. The code is cleanly factored into per-benchmark modules, a shared utility module (`common.py`), and sampler adapters. The framework is designed for reproducibility of OpenAI's published benchmark numbers, with all data loaded from public Azure blob storage URLs. The repository is deprecated as of July 2025 and will not receive updates for new models or benchmarks, though it will continue to host reference implementations for HealthBench, BrowseComp, and SimpleQA.