Dejavu is a single-page web application that provides a modern UI for browsing, searching, and managing data in Elasticsearch and OpenSearch clusters. It is built with React 18, Redux, Redux-Saga, and Ant Design, and leverages the ReactiveSearch library for search UI components. The application runs entirely client-side, communicating directly with the Elasticsearch REST API. It supports CRUD operations, data import/export (JSON/CSV), field mapping management, term-based filtering, global search, and a search preview builder. The codebase is organized as a monorepo with two packages: a reusable browser component library (`@appbaseio/dejavu-browser`) and the main application (`dejavu-main`). The architecture follows a standard Redux pattern with sagas for side effects, and uses react-virtualized for high-performance data grids. While the code is well-structured and feature-rich, it relies on several outdated dependencies (Redux 3.x, redux-saga 0.16, react-router-dom 4.x, emotion 9.x) and uses Flow type annotations, which are now deprecated. The project appears to be in a stale maintenance state with no recent commits.
This repository is a monorepo providing a React component library for swipeable views (carousels/ tabs) with touch and mouse support. It is split into multiple packages: `react-swipeable-views` (browser implementation), `react-swipeable-views-core` (shared utilities), `react-swipeable-views-utils` (higher-order components for auto-play, virtualize, and keyboard binding), and `react-swipeable-views-native` (experimental React Native support). The main component (`SwipeableViews`) uses CSS transitions and transforms to animate slides, with lazy loading and resistance effects. The HOCs provide composable enhancements: `autoPlay` adds timed auto-advance with visibility change handling, `virtualize` renders only a window of slides for large lists, and `bindKeyboard` enables arrow key navigation. The library is well-tested with mocha, chai, and sinon, and has a comprehensive documentation site built with Next.js. However, the codebase is dated (class components, outdated Babel and Next.js versions, no hooks) and maintenance appears stagnant, with many open issues and infrequent updates. The core utility functions are clean, reusable, and demonstrate good software engineering practices.
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.
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.
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.
This repository contains the starter files and completed solutions for Wes Bos's 'JavaScript30' course - a collection of 30 vanilla JavaScript exercises, each a self-contained mini-application demonstrating a specific browser API or JavaScript pattern. The exercises cover: DOM manipulation and events (Drum Kit, Clock, Whack-a-Mole), modern array methods (Array Cardio Days 1-2), localStorage persistence, HTML5 Canvas drawing, custom video player controls, speech recognition/synthesis, webcam/media devices API, geolocation, CSS variables manipulation, flexbox transitions, sticky navigation, drag-to-scroll, type-ahead autocomplete, shift-click range selection, konami code detection, scroll-triggered animations, dropdown navigation, link highlighting, and various console/debugging techniques. Each exercise exists as a pair: START (boilerplate HTML/CSS) and FINISHED (working solution). The code is intentionally written as inline scripts in HTML files to match the video tutorials, not as modular, reusable components. There are no build tools, test suites, or dependency management (except browser-sync for live-reload in a few exercises). The repo is actively maintained to stay in sync with the course videos, but the content is pedagogically frozen - PRs that improve code but deviate from the videos are explicitly rejected.
Blobby Volley 2 is a complete, cross-platform 2D multiplayer volleyball game implemented in C++ with Lua scripting for AI bots and game rules. It features local and networked multiplayer (client-server via a bundled, modified RakNet stack), a dedicated server for online matchmaking, replay recording/playback, and a custom immediate-mode GUI built on SDL2. The architecture uses a state machine pattern (State base class with derived menu, game, and replay states), abstracted rendering backends (OpenGL, SDL, Null), and a custom physics engine with integrated Lua-driven rule logic. The project is built with CMake and targets Windows, Linux, macOS, Android, and Nintendo Switch, with GitHub Actions CI for multiple compilers and platforms. The game's core loop processes player input (keyboard, mouse, joystick, touch, or Lua script) through an InputManager, feeds it into DuelMatch (which combines GameLogic and PhysicWorld for physics and rules), and renders via RenderManager. Network games use RakNet for reliable UDP communication with prioritized packet handling; the dedicated server manages lobbies, matchmaking, and state broadcasting. Replays are recorded as binary state snapshots (using GenericIO serialization) and can be played back in-game. The Lua API provides bot developers with real-time game state queries, physics prediction functions, and callbacks for serve and bounce events, along with older legacy scripts in data/scripts/old. While the codebase demonstrates solid engineering (template-based serialization, abstracted file I/O with PhysFS, cross-platform build systems), it carries technical debt from aging dependencies (RakNet, Lua 5.3, SDL2, TinyXML2) and heavy use of platform-specific ifdefs. Some components, like the custom IMGUI and RakNet integration, are tightly coupled and not easily extractable, but the GenericIO serialization layer and FileSystem wrapper are self-contained and could be reused in other C++ projects needing binary I/O or virtual file system access.
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.
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.
ProjectX is an Android multi-module repository containing a support library (`support`, `support_v1`) and demo applications (`app`, `app_old`). The support library provides a wide range of reusable utilities, UI components, security helpers, and builder patterns for Android development, published as a Maven artifact. The demo app showcases these components through interactive activities organized by category (widgets, drawables, others), using an MVP-like architecture. The codebase demonstrates strong engineering practices with fluent builders, composable conditions, and view recycling patterns, but carries legacy baggage from duplicate modules and deprecated classes. The last commit is recent, indicating ongoing maintenance, though some technical drift is present due to reflection usage and outdated API references.
This repository implements a Field-Programmable Gate Array (FPGA) based emulator for Nintendo Game Boy and Game Boy Color systems, specifically targeting the Analogue Pocket handheld console. The design consists of hardware description language (Verilog/VHDL) modules that replicate the original hardware components including a Z80-compatible CPU core (T80), memory controllers, video display subsystem, four-channel audio processing unit, input handling, cartridge interface with various Memory Bank Controller (MBC) implementations, save state functionality, and real-time clock support. The architecture follows a modular approach with clear separation of concerns between subsystems, interconnected through well-defined interfaces. The project demonstrates significant effort in achieving hardware-level accuracy while incorporating modern features like save states, fast forwarding, and custom palettes. While the codebase shows signs of active maintenance and ongoing development, it remains tightly coupled to the target FPGA platform (Cyclone V) and associated Intel/Altera toolchain, which limits immediate portability to other hardware platforms.
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.
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.
BeikeShop is a full-featured, open-source e-commerce platform built on PHP 8.2+ and Laravel 12. It provides a complete online store solution with separate admin panel and shop frontend, supporting multi-language (10+ locales), multi-currency, and a plugin ecosystem. The system includes product management, shopping cart, checkout flow, payment integrations (Stripe, PayPal, Wtp), shipping methods, order management, RMA (returns), customer accounts, wishlists, and a page builder for customizing storefront layouts. It also features a web installer, console commands, and a design builder for mobile app home screens. The architecture follows a modular monolith pattern with clear separation between admin, shop, and API layers. It employs a custom hook/event system for extensibility, a repository-service pattern for data access, and Blade components for reusable UI. The codebase includes a sophisticated plugin framework with scaffolding commands, migration management, and asset publishing. While the platform is functionally rich and actively maintained, it exhibits some technical debt including machine-translated language files, mixed frontend stacks (Vue 2 + jQuery), and occasional security concerns (open CORS, disabled SSL verification).
Notion is a tiling, tabbed X11 window manager for keyboard-centric users, forked from Ion3. It provides a modular architecture with a C core (ioncore) and loadable modules (tiling, menu, query, statusbar, dock, multihead, etc.). Lua is the primary configuration and extension language, powered by the libextl library which auto-generates C-to-Lua bindings from annotated function declarations. The window manager manages a hierarchical region model (frames, workspaces, groups, clients) with dynamic dispatch via function tables. It includes a full-featured status bar system with a separate daemon (ion-statusd) and dozens of user-contributed meter scripts. Session management via XSMP, multi-monitor support (Xinerama/XRandR), and a remote-control socket (notionflux) are built-in. The codebase is mature but shows signs of technical drift: it relies exclusively on X11 (no Wayland), bundles a portable snprintf from 2000, carries legacy workarounds for long-obsolete systems, and many contrib scripts are unmaintained or broken. Nevertheless, the core architecture and utility libraries (libtu, libextl, libmainloop) are well-crafted and potentially reusable in other C projects.
Outpacket is a comprehensive cheatsheet/reference guide that maps traditional impacket penetration testing workflows to modern alternative tools like gopacket, Titanis, NetExec, and others. It serves as a static documentation resource for security professionals working with Windows environments, particularly Active Directory attacks. The repository contains only a single README.md file organized into sections covering authentication, remote execution, Kerberos operations, SMB/file operations, credential dumping, enumeration, AD/LDAP operations, auth coercion, certificate attacks, and exotic credential harvesting techniques. Each section provides command examples for multiple tools alongside explanatory notes about tool-specific behaviors and limitations.
VxKex is a Windows compatibility layer that enables applications designed for Windows 8, 8.1, and 10 to run on Windows 7 SP1. It achieves this by injecting a core DLL (KexDll) into target processes via Image File Execution Options (IFEO), rewriting import tables to redirect API calls to extended DLLs (KxBase, KxUser, KxCom, KxDx, etc.) that implement missing or modified functions. The project also includes a kernel-mode driver (KexKMSD), a configuration GUI (KexCfg), an installer (KexSetup), a shell extension (KexShlEx), a log viewer (VxlView), and a launcher (VxKexLdr). The codebase is deeply tied to Windows 7 internals, using undocumented NT APIs, assembly syscall hooks, and version spoofing. It is a monolithic collection of tightly coupled C projects built with the Windows 7.1 SDK and custom build utilities. While functionally impressive and demonstrating deep reverse-engineering skill, the code is informal, contains many stubs and TODO comments, and has limited reusability outside its specific context.
This repository is a collection of AI agent skill definitions for the Higgsfield platform, enabling automated content creation across multiple domains including brand identity, product photography, website generation, video explainers, YouTube thumbnails, and 3D game assets. Each skill is self-contained in a folder with a SKILL.md entry point and references directory, designed for consumption by AI agents (Claude, Cursor, Codex). The repo also includes deterministic scripts for GLB processing, texture pipeline, procedural rigging, and brandbook generation, as well as CI validation workflows. While primarily a skill library, it contains reusable engineering patterns such as a brandkit state machine, stdlib-only GLB patching, and a texture seam-fix pipeline. The codebase is well-structured with version sync enforcement and anti-slop design rules, but relies on external tools (Blender, ImageMagick, LibreOffice) and live Higgsfield API endpoints.
AgentWeb is an Android library that wraps the native WebView to simplify common tasks such as page loading, JavaScript bridge communication, file upload/download, video playback, permissions handling, and custom progress indicators. It exposes a fluent builder API (AgentWeb.with()) for configuration and uses a middleware/delegate pattern (MiddlewareWebClientBase, MiddlewareWebChromeBase) to allow multiple WebViewClient/WebChromeClient interceptors. The library also includes an optional file-chooser module for camera/gallery access with compression. It has been widely adopted (9.4k stars) but is now stale: last commit appears outdated, JCenter references remain, and test coverage is negligible. The architecture is well-designed for extensibility, but the codebase shows signs of drift (old Kotlin version, deprecated APIs, reflection hacks, Chinese comments).