This repository is a project skeleton (starter template) for creating new Sulu CMS applications. It provides the recommended directory structure, Symfony framework configuration, Sulu bundle integration, console entry points (admin and website contexts), and asset building setup for the JavaScript-based admin interface. In production, it serves as the foundation for a multi-lingual, multi-portal website with a rich admin panel. The architecture is a Symfony-based monolith with separate admin and website kernel contexts, HTTP caching support, Doctrine ORM for persistence, and built-in search, media management, and security features. Key entry points are 'public/index.php' for web requests and 'bin/console' for CLI commands. External dependencies include MySQL, Node.js/npm for frontend asset compilation, and various Symfony and Sulu bundles. The codebase follows modern Symfony best practices with strict coding standards, extensive linting, and CI/CD pipelines.
Material Motion for JavaScript is a reactive programming library designed for handling motion and gestures in web applications. It provides an observable implementation with operators similar to RxJS, gesture recognition components (Draggable, Swipeable, Tossable), physics-based animations using springs, and DOM integration utilities for connecting gestures to visual effects. The library enables developers to create interactive UI components by composing streams of events through operators to produce animated styles. The architecture follows a modular package structure with core library, demos, and testing utilities. The core library is organized by functionality: observables, operators, interactions, and DOM utilities. It uses TypeScript with strict typing and employs a build system using Rollup for bundling. Key entry points are in packages/core/src/index.ts and the various feature modules that export specific functionalities. The repository shows active maintenance with recent commits (last updated 2026-04-15), ongoing issue management, and comprehensive documentation. While there are some signs of technical drift in build tooling (older versions of webpack, rollup, and TypeScript in devDependencies), the core library code appears to be keeping pace with modern TypeScript practices and reactive programming patterns.
This is a full-stack web application starter kit combining Angular (frontend) and Spring Boot (backend) with JWT-based authentication. The system provides user registration, login, role-based access control (USER/ADMIN), and protected API endpoints. The frontend communicates with the backend via RESTful APIs, with authentication handled through JWT tokens stored in cookies. The architecture follows a standard client-server pattern with clear separation of concerns: Angular handles UI presentation and user interactions, while Spring Boot manages business logic, data persistence, and security. Key features include route guards for client-side protection, custom JWT filters for server-side authentication, and centralized service layers for API communication.
This repository is a curated collection of management and engineering leadership resources, not a software application or data pipeline. It contains a personal README detailing the author's management philosophy, recommended readings on topics like AI, burnout, inclusivity, and technical leadership, a blog post on managing teams during COVID-19, documentation outlining expectations and meeting practices, and reusable templates for goal setting, artifacts, and one-on-one meetings. The content serves as a practical guide for managers to improve team dynamics, feedback processes, and leadership effectiveness. While it lacks executable code or data processing components, the resources are well-organized and actionable, offering value as a reference for engineering leadership practices.
TOra is a database administration and development toolkit primarily for Oracle but also supporting MySQL, PostgreSQL, DB2, and Teradata. It provides a modular Qt-based GUI application with database connection management, SQL worksheet with syntax highlighting and execution, schema browser, result viewing/exporting, PL/SQL editor/debugger, tuning tools, backup utilities, and security/session management. The architecture follows a plugin/extension pattern where tools inherit from base classes, uses MVC for result display, and implements abstraction layers for database connectivity. Key entry points are in src/main/ for application startup, connection dialogs, and preferences.
BLURR is a library that integrates Hugging Face transformers with fastai for NLP tasks. It provides high-level, mid-level, and low-level APIs to train and deploy transformer models for text classification, token classification, question answering, summarization, translation, and language modeling. The library leverages fastai's data block API and learner system, wrapping Hugging Face models to work seamlessly within the fastai training loop. Key components include custom data blocks for text processing, model wrappers for Hugging Face integration, specialized loss functions, and callbacks for optimization. The repository includes extensive examples and notebooks demonstrating usage with standard datasets like GLUE, SQuAD, and CNN/DailyMail.
OplusEdlTool is a cross-platform desktop application (Avalonia UI / .NET) for flashing, backing up, and managing Oplus (Oppo/OnePlus) Android devices in Qualcomm EDL (Emergency Download) mode. The tool provides a graphical interface for reading partition tables, backing up individual partitions, merging super partition images from JSON definitions (super_def.json), applying firmware patch files, and verifying file integrity via SHA checksums. It integrates with Qualcomm's fh_loader.exe for low-level device communication and supports Oplus-specific ROM formats (.ofp, .ops). The application stores working data in LocalApplicationData, generates XML partition reports, and includes comprehensive logging. It is bilingual (English/Chinese) and explicitly warns users about dangerous operations like flashing the persist partition.
BMad Game Dev Studio is a content module for the BMad Method, providing a comprehensive set of AI agent skills and workflows for game development. It is not a traditional software application but a structured collection of markdown files, templates, and small scripts that an AI agent (such as Claude with BMad) interprets to guide users through preproduction, design, technical planning, production, and testing phases. The repository includes 7 agent definitions, 28 workflow skills, game engine knowledge bases (Godot, Unity, Unreal, Roblox, Phaser), and a documentation website built with Astro. The primary purpose is to automate and standardize game development tasks via LLM-based agents, covering brainstorming, game design documents, narrative design, UX specifications, architecture decisions, epic/story creation, code review, and various testing types. The architecture is entirely file-based: each skill has a SKILL.md entry point, step-by-step instructions, templates, and validation checklists. The system relies on the BMad Method core for orchestration and customization resolution. While not a code library, the repo demonstrates high organizational craftsmanship in its workflow design and template patterns.
MSL (Minecraft Server Launcher) is a Windows desktop application for managing Minecraft server instances. It allows users to create, configure, launch, and monitor Java and Bedrock Minecraft servers, including mod/plugin management, server core downloading, world backups, and crash analysis. The application also provides networking capabilities through FRP tunneling (supporting multiple providers like MSLFrp, OpenFrp, SakuraFrp, ChmlFrp, and custom frpc) and P2P/STUN connections for online play. It includes a download manager for concurrent file downloads, a system resource monitor, and a terminal emulator (ConPTY) for server console interaction. The architecture is a monolithic desktop application built with .NET Framework 4.7.2 using WPF and the HandyControl UI library. The UI is composed of pages loaded into a main window, with separate modules for server runner (dashboard, console, settings), FRP management, download manager, and settings. Configuration is stored in JSON files with atomic writes. The application integrates with several external APIs (MSL backend, CurseForge, Modrinth, BMCLAPI, and various FRP provider APIs) via a custom HTTP service. Key entry points include App.xaml.cs (application initialization), MainWindow.xaml.cs (navigation hub), and ServerRunner.xaml.cs (per-server window with child pages). Data flows involve HTTP requests to external APIs, local JSON config files, and process I/O for server and FRP binaries. The application uses a custom ConPTY terminal emulation library for server console I/O and a language system for internationalization. External dependencies include .NET Framework 4.7.2, HandyControl (submodule), Newtonsoft.Json, SharpZipLib, AvalonEdit, CurseForge .NET API client, Modrinth .NET client, QR code library, and ConPtyTermEmulatorLib. The application relies on external services: MSL API (mslmc.cn), CurseForge, Modrinth, BMCLAPI, and various FRP provider APIs.
A La Carchy is a two-panel TUI (Terminal User Interface) application for Omarchy Linux that serves as a system debloater and optimizer. It provides an interactive interface for removing preinstalled applications and web apps, configuring system settings (keybindings, display, appearance, etc.), managing ASUS ROG hardware controls, applying themes from wallpaper colors, installing community themes, and backing up/restoring configurations. The architecture is a single bash script that implements a sophisticated terminal UI with guided dialogs for complex configurations, direct modification of system configuration files with safety features like backups and confirmations, and integration with Omarchy-specific utilities and standard Linux tools.
This repository implements a multi-agent orchestrator system for healthcare workflows, specifically designed for cancer care/tumor board scenarios. The system coordinates specialized AI agents (Patient History, Radiology, Patient Status, Clinical Guidelines, Report Creation, Clinical Trials, Medical Research) via Semantic Kernel group chat, with an Orchestrator agent facilitating collaboration. It provides both Microsoft Teams integration and a React/Vite web interface for user interaction. The architecture includes a Python/FastAPI backend handling WebSocket connections and Bot Framework messages, agent-specific tools for data access and external API integration, and an evaluation framework for assessing agent performance. Infrastructure is provisioned via Azure Bicep templates deploying AI services, storage, compute, and networking resources.
The hCaptcha Vue Component Library provides Vue 2 and Vue 3 components for integrating hCaptcha into Vue applications. The library consists of two packages (@hcaptcha/vue-hcaptcha for Vue 2 and @hcaptcha/vue3-hcaptcha for Vue 3) built from a shared Vue component source. The component handles loading the hCaptcha API script, rendering the widget, and emitting events for verification, expiration, and other hCaptcha callbacks. It also provides methods to programmatically execute and reset the challenge. A notable utility in the library is the script loader (hcaptcha-script.js) which ensures the hCaptcha API is loaded only once per page using a promise-based pattern. This utility is framework-agnostic and could be reused in other projects requiring singleton script loading. The repository is set up as a monorepo using Lerna, with separate build processes for Vue 2 (using Vue CLI) and Vue 3 (using Vite). While the component itself is well-maintained and functional, the build toolchain shows signs of technical drift with outdated dependencies (e.g., Vue CLI 3, Vite 2, Jest 26). The project is actively maintained with CI pipelines for building, testing, and releasing new versions.
This repository implements the research paper 'Image as an IMU: Estimating Camera Motion from a Single Motion-Blurred Image'. It provides code for training a neural network to estimate camera motion (rotation and translation) from a single motion-blurred image, using synthetic data generated from ScanNet++ and real-world fine-tuning data. The repository includes utilities for processing data from the StrayScanner iOS app, evaluating baselines (COLMAP, DROID-SLAM, MASt3R), and running real-time demos. The core contribution is a model that predicts optical flow, depth, and camera pose from a blurred image, then resolves motion direction ambiguity via photometric consistency checks.
Elib2Ebook is a .NET 10 application that downloads books from 60+ online libraries (Litres, MyBook, BookRiver, etc.) and converts them into standard ebook formats (EPUB, FB2, CBZ, JSON, TXT). It is a dual-deployment solution: a CLI tool and a Blazor web UI, both sharing a core domain and service layer. The architecture is a layered .NET solution with Domain, DomainServices, and per-site ExternalServices projects, using a reflection-based GetterFactory to auto-discover site adapters. The system handles site-specific anti-bot measures, authentication, and pagination, then normalizes content into a common domain model before passing it to format-specific builders.
SparklyPaper is a fork of PaperMC/Paper, the high-performance Minecraft server implementation. It applies a curated set of custom performance and feature patches on top of upstream Paper, with a focus on server tick optimization and configuration via a sparklypaper.yml file. The build is Gradle-based and produces a patched server jar; CI workflows automatically track upstream Paper and build the project. The repository is structured as a standard Paper fork: a Gradle multi-project build with a sparklypaper-api module and a patched server module. The runtime entry point is the standard Paper patched Minecraft server main class; custom behavior is introduced through patches that modify world ticking, chunk loading, and player data handling. The sparklypaper.yml file controls per-world settings, with defaults and per-world overrides. External dependencies include upstream Paper, Minecraft server jars, Gradle, and GitHub Actions. The repository also contains design notes (PARALLEL_NOTES.md), performance results (RESULTS.md), and a curated list of known-broken patches from other forks (BORKED_PATCHES.md). It is not a library or service; it is a server distribution for running Minecraft servers. No test suite is visible; CI focuses on build and auto-update.
Colab is a desktop IDE built with Electrobun (Bun + native Zig binaries) that combines a code editor (Monaco), integrated web browser, terminal, Git client, and local AI code completions (llama.cpp) into a single workspace. It features a plugin system that allows third-party extensions to contribute commands, custom UI slates, file decorations, context menus, and more. The application uses a main process (Bun) for system operations (file system, Git, terminal, AI) and a renderer process (SolidJS webview) for the UI, communicating via typed RPC. It includes a local database (GoldfishDB) for workspace and settings persistence, cloud sync with encryption, and analytics tracking. The architecture is modular with a focus on extensibility, though some components (store, main index) are monolithic and contain technical debt.
This repository provides a Dockerized implementation of RaspAP, a wireless router software for Debian-based devices. The container runs systemd to manage multiple services including hostapd (for Wi-Fi access point), dnsmasq (for DHCP/DNS), and the RaspAP web interface. It uses the host's network stack and requires privileged access to configure network interfaces and firewall rules. The setup process involves installing RaspAP via the official installer script, then applying environment-specific configurations through shell scripts that map environment variables to configuration files. The architecture is a single-container design that leverages systemd for process management inside the container. Key components include an environment setup script (env-setup.sh) that dynamically updates configuration files based on prefixed environment variables, a firewall script (firewall-rules.sh) that configures NAT and forwarding rules, and a simple PHP password generator (password-generator.php) for securely hashing web GUI credentials. The container exposes the RaspAP web interface on port 80 (mapped to 8081 on the host) and relies on the host's wireless and Ethernet interfaces for operation. Notable reusable components demonstrate solid engineering practices: the env-setup.sh script implements a clean pattern for mapping environment variables to configuration file key-value pairs using associative arrays and sed-based updates, which could be adapted to other applications with minimal changes. The password-generator.php correctly uses PHP's password_hash function with BCRYPT, showcasing secure password handling. While the Dockerfile follows common patterns for running systemd in containers and the firewall script contains interface-specific assumptions, the overall maintainability is strong with recent commits, active CI/CD workflows, and no reported dependency issues.
Bob is a Scheme language implementation consisting of a Python interpreter, compiler, and virtual machine (VM), plus an optional C++ VM implementation (BareVM). The system compiles Scheme source code to custom bytecode, which can be executed by either the Python VM or the C++ BareVM. It includes features like bytecode serialization/deserialization and WebAssembly compilation. The architecture is modular with clear separation of concerns: parser, compiler, bytecode handling, VM execution, built-in functions, expression representation, and environment management. Key entry points are in bob/cmd.py (command-line interface) and example scripts demonstrating interpretation, compilation, and execution workflows.
This is a Terraform module for deploying a production-grade HashiCorp Vault cluster on Google Compute Engine (GCE). It provisions all necessary networking (VPC, subnets, NAT, firewalls), a GCS bucket for Vault's storage backend, a KMS key for auto-unseal and TLS encryption, and manages the full lifecycle of Vault nodes via a managed instance group with autoscaling and autohealing. The module supports both internal and external load balancers, and includes an optional submodule (`modules/cluster`) for organizations that need to separate concerns (e.g., shared VPC setups). The core logic resides in the `modules/cluster` submodule, which contains instance templates, load balancer configuration, health checks, IAM bindings, and self-signed TLS certificate generation. A startup script template handles Vault installation, configuration, mTLS setup, logging agents, and security hardening (core dumps disabled, swap disabled, unprivileged user). The module is highly parameterized with ~60 input variables, allowing customization of machine types, Vault versions, networking, and TLS management. It is designed for high availability (HA) with GCS backend and auto-unseal via Cloud KMS. The repository includes examples, integration tests using Kitchen/Terraform and Inspec, and CI/CD pipelines, indicating a mature, community-maintained module. The code is clean and follows Google's Cloud Foundation Toolkit conventions, but it is relatively conventional Terraform infrastructure code, not particularly novel or reusable beyond its intended purpose.
GraphDreamer is a PyTorch-based system for generating compositional 3D scenes from scene graphs. It implements a coarse-to-fine approach where objects are represented as implicit signed distance functions (SDFs) and optimized using gradient signals from 2D diffusion models (DeepFloyd IF for coarse stage, Stable Diffusion for refinement). The system takes text prompts describing objects and their relationships, constructs a scene graph, and generates 3D meshes representing the composed scene. Architecture follows the threestudio framework with modular components for data handling, geometry, materials, guidance, rendering, and system orchestration. Key entry points are in launch.py which supports training, validation, testing, and export modes via command-line interface.