This is a mature, widely-used webpack plugin and loader for extracting CSS into separate files. It provides a custom module type (`CssModule`), dependency (`CssDependency`), and runtime code for loading CSS chunks, including support for async loading, source maps, HMR, CSS modules, and public path customization. The plugin is now deprecated in favor of webpack's native CSS support (`experiments.css`), but remains functional and receives maintenance updates. The codebase demonstrates advanced webpack plugin patterns: custom module factories, hook-based runtime generation, schema validation via `schema-utils`, and a client-side HMR runtime. The test suite is extensive, covering many edge cases with snapshot testing and integration tests across multiple Node versions and operating systems. The architecture is tightly coupled to webpack 5 internals, which limits reusability outside of webpack plugin development, but the patterns (custom modules, boolean matcher, URL normalization) are instructive for other webpack plugin authors.
TCPDF is a PHP library for programmatic PDF generation, originally a monolithic single-file engine. The current version (7.0.7) is a compatibility facade that delegates all rendering to the modern `tecnickcom/tc-lib-pdf` engine, preserving the legacy 291-method public API while the internal engine is replaced. The library is explicitly deprecated and in maintenance-only mode; users are encouraged to migrate to `tc-lib-pdf` directly. It provides a comprehensive set of features for creating PDF documents: text and HTML rendering, images, barcodes (1D and 2D), forms, digital signatures, encryption, PDF/A compliance, and more. The codebase includes a rich test suite (PHPUnit) with a reusable base test class, a smoke test runner for all 68 example scripts, and a method-mapping tool that generates the authoritative documentation of delegation status. The deposit is a library, not a standalone application, and is intended to be integrated into PHP applications via Composer.
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 the companion code for the first edition of 'Hands-on Machine Learning with Scikit-Learn and TensorFlow' (2017). It contains a collection of Jupyter notebooks teaching fundamental and advanced machine learning concepts, covering classification, SVMs, decision trees, ensemble methods, dimensionality reduction, and deep learning with TensorFlow 1.x (including CNNs, RNNs, autoencoders, and reinforcement learning). The code is educational, with step-by-step implementations, inline explanations, and exercise solutions. It is not a production application but a self-contained learning environment, supplemented with datasets (California housing, OECD life satisfaction, MNIST) and a Docker setup for reproducible execution. Significant technical drift exists: TensorFlow 1.x APIs, deprecated scikit-learn imports, and Python 2/3 compatibility shims make the notebooks incompatible with modern environments without substantial rewriting. The README explicitly directs users to the second edition repository for up-to-date code.
socketio-wildcard is a small Node.js library that adds a wildcard event listener ('*') to socket.io, allowing developers to catch all incoming events in a single handler. The core implementation is a middleware that intercepts the `onevent` method of a socket, emitting a wildcard event before delegating to the specific event handler. It supports both server-side and client-side usage, with a single-file module that exports a factory function. The library is deprecated as socket.io 2.0.4+ includes native middleware for packet interception, which supersedes the wildcard pattern. The codebase is clean, well-tested, and follows modern JavaScript standards, but its functionality is largely redundant with current socket.io features. The repository includes comprehensive integration tests using mocha and power-assert, and CI configurations for Travis and CircleCI.
This repository is the open-source CLI client for Amazon Q Developer (formerly CodeWhisperer), now deprecated in favor of the closed-source Kiro CLI. It is a Rust workspace with approximately 2000 files, building two main binaries: `q` (terminal chat assistant) and `qchat` (legacy chat binary). The codebase is dominated by auto-generated AWS SDK client crates (amzn-codewhisperer-client, amzn-codewhisperer-streaming-client, amzn-qdeveloper-streaming-client, amzn-consolas-client, amzn-toolkit-telemetry-client), which are Smithy-generated and checked in. Hand-written code includes the chat CLI interactive loop, an agent framework with MCP (Model Context Protocol) support, a semantic search client using local ONNX models (MiniLM) and BM25 indexing, authentication (OIDC with device grant flow), telemetry, and an OS abstraction layer. The architecture is essentially a monolithic CLI application with multiple supporting libraries. About 90% of the source files are generated code, which means the hand-crafted components are relatively small. The project was previously actively maintained but is now effectively archived; the README states only critical security fixes will be accepted.
Ruote is a mature Ruby workflow engine (BPM) that orchestrates long-running business processes through a tree of expressions (sequence, concurrence, if, participant, etc.). The engine routes workitems to registered participants, persists process state via pluggable storage backends (in-memory, file system, composite), and supports process definitions in Ruby DSL, XML, JSON, and a custom Radial format. It provides a full API via Ruote::Dashboard for launching, canceling, pausing, and inspecting processes, along with error handling, timers, observers, and cross-process communication via await/listen. The codebase is well-structured with a clear expression lifecycle, participant abstraction, and a service-oriented architecture. However, the project is explicitly deprecated—the README states 'Do not involve ruote in your new project' and directs users to the successor flor. Development ceased around 2013, and the code relies on outdated Ruby idioms and dependencies (e.g., sourcify, parslet 1.4.0), making it unsuitable for modern Ruby projects without significant adaptation.
Upterm is a terminal emulator for the 21st century, built as an Electron desktop application with TypeScript and React. It provides an IDE-like terminal experience with features such as autocompletion (for git, npm, brew, and many other commands), output prettyfiers (JSON tree, git grep, image display), multiple tabs and split sessions, a custom shell parser, and a plugin system. The application uses node-pty for pseudo-terminal management and Monaco Editor for the prompt input. It also includes a full VT100/xterm-compatible terminal emulator (Output.ts) that handles ANSI escape sequences, scrolling, cursor movements, and SGR attributes. Architecturally, Upterm follows a modular pattern with services (FontService, HistoryService, GitService, etc.) that communicate via RxJS observables, a plugin manager that registers autocompletion providers and prettyfiers, and a shell layer that parses commands and manages jobs. The codebase is well-structured and demonstrates non-obvious craftsmanship in areas like the history trie for fuzzy matching, man page parsing for flag extraction, and the terminal buffer implementation. However, the project is explicitly deprecated and unmaintained. The README states it is no longer accepting pull requests or issues. The codebase relies on outdated dependencies (Node 8.11.0, Electron 2.0.10, React 16.2.0) and has several incomplete features and security concerns (e.g., execFile with user-controlled input). Despite its quality, the technical drift is high, and the repository should be considered a reference or learning resource rather than a production-ready tool.
This repository is a deprecated ONNX Model Zoo containing thousands of pre-trained models (mostly computer vision, some NLP and generative AI) exported to the ONNX format from PyTorch (timm, torchvision) and other frameworks. It also contains turnkeyml benchmark artifacts (turnkey_stats.yaml) that record export success, model metadata, ONNX operator counts, and system environment for each model across opsets 16–18. The primary purpose was to provide a centralized collection of ready-to-use ONNX models for inference and to validate cross-version ONNX export compatibility. However, the repository is explicitly deprecated (LFS disabled July 2025) and users are redirected to Hugging Face. The codebase consists almost entirely of binary model files and YAML metadata; the only reusable software components are a few preprocessing scripts (e.g., imagenet_preprocess.py, face_preprocess.py) in the validated/ directories. There is no application logic, no API, no training pipelines—this is purely a model distribution and benchmark data repository. Reproducibility is low due to hardcoded paths, frozen env snapshots that are out of date, and reliance on external model sources whose weights may have changed.
KindEditor is a client-side, WYSIWYG HTML editor library written in vanilla JavaScript. It replaces standard <textarea> elements with a rich text editing interface featuring a toolbar, iframe-based design mode, undo/redo stack, and a plugin system for extensibility. The architecture is built around custom DOM abstractions (KNode, KRange) that normalize cross-browser differences (IE6+, Firefox, WebKit, Opera), a widget system (KWidget, KDialog, KMenu) for UI components, and a built-in event system. The editor supports image/table/link insertion, multi-image Flash upload (SWFUpload), HTML sanitization, and MS Word paste cleanup -- all configurable through a central options object. Despite its full feature set and well-documented API, the project has been explicitly abandoned by its maintainers as stated in the README, with no upgrades planned. The codebase is heavily weighted toward legacy browser workarounds, uses an outdated build system (Grunt 0.4.1), bundles deprecated third-party libraries (SWFUpload, Firebug Lite, QUnit v1.x), and exhibits security risks (eval usage in JSON parsing). It remains functional for modern browsers but carries significant technical debt, making it unsuitable for new projects without heavy modernization.
This is the Anko library for Android, a Kotlin DSL that provides type-safe builders for UI layouts, SQLite queries, intents, dialogs, async tasks, logging, and other common Android patterns. The repository additionally contains a code generator (using ASM to parse Android SDK classes) that produces extension functions for views, properties, listeners, and services per API level, and an IntelliJ/Android Studio plugin that includes XML-to-Anko conversion, live preview of DSL layouts, and refactoring intentions. The library is officially deprecated (see GOODBYE.md) in favor of Jetpack Compose, Splitties, and Android KTX; the last commit was in 2019. The codebase is well-structured overall, but the generated files are massive and repetitive, and the library has not kept pace with the Android ecosystem (e.g., still uses android.support libraries, GlobalScope for coroutines, and targets SDK versions up to 28). Reusable components include the static commons (Logging, Async, Intents, AlertBuilder), the code generator's class tree and rendering pipeline, and the SQLite query builders.
ShaderlabVS is a Visual Studio Extension (VSIX) designed to enhance the development experience for Unity Shaderlab, CG, and HLSL files within the Visual Studio IDE. It provides core editor features including syntax highlighting, code completion, outlining, quick info tooltips, and signature help. The architecture is divided into a core extension project (`ShaderlabVS`) that integrates with the Visual Studio Editor API, a data library (`ShaderlabVS.Data`) that manages keyword and function definitions via a custom `.def` file format, and build tools (`ShaderlabVS.LexTools`) that generate lexer tables using `gplex.exe`. Despite the functionality, the project is effectively stale and superseded. The README explicitly states that ShaderlabVS has been upgraded to "Omni Shader Tools for Unity," which features a completely rewritten parser. The codebase targets Visual Studio 2013, 2015, and 2017, relying on .NET Framework 4.5 and older VSSDK APIs. This makes it incompatible with modern Visual Studio versions (2019/2022) without significant refactoring. While the code demonstrates solid engineering practices for its time (MEF usage, separation of data/logic, unit tests), it is no longer the recommended solution for Unity shader development in Visual Studio. The repository contains a custom lexer generator and a robust data parsing system that could serve as a reference for building language services, but the extension itself is legacy. Users seeking similar functionality should migrate to the Omni Shader Tools project mentioned in the README.
NCalc is a .NET library for parsing and evaluating mathematical expressions, written in C# and targeting .NET Framework 3.5. It uses ANTLR 3.3 to generate a lexer and parser from a custom grammar, producing an abstract syntax tree (AST) of logical expressions. The library supports arithmetic, logical, bitwise, comparison, and ternary operators, as well as built-in functions (Abs, Sin, Round, etc.) and user-defined functions and parameters via event handlers. It also includes expression caching, error detection, and serialization. The codebase is well-structured for its era, with a clear separation between grammar, domain model, and evaluation logic. However, it is explicitly unmaintained and superseded by a newer version (ncalc/ncalc). The project uses outdated dependencies (ANTLR 3.3, .NET 3.5) and includes binary DLLs, making it unsuitable for modern .NET projects without significant migration effort. The primary value is as a historical reference or for understanding expression evaluator design patterns.
Vue Native Core is a deprecated fork of Vue.js 2.x that compiles Vue component templates into render functions compatible with React Native (iOS/Android) and React Web. It provides a full reactive state management system (Vue's observer pattern), virtual DOM diffing, and a template compiler pipeline that transforms .vue single-file components into JavaScript modules usable by React Native's Metro bundler. The architecture mirrors Vue 2: core reactivity (Dep, Watcher, Scheduler), virtual DOM (createElement, patch), and a multi-stage compiler (parser → AST → code generator) with platform-specific backends for native and web. It also offers runtime helpers to emulate Vue directives (v-if, v-for, events) and component lifecycle in React. However, the project is explicitly deprecated, depends on outdated versions (Babel 6, React 16.8, React Native 0.45–0.59+), and uses deprecated React lifecycle methods (UNSAFE_componentWillMount). The codebase shows heavy modification of core Vue files, making it difficult to merge upstream updates, and its build system is complex and fragile. Despite these issues, the reactive state wrapper (Vue.observer) and the template-to-render compilers demonstrate non-trivial adaptation of Vue to React ecosystem.
This repository provides a deprecated Docker image for running Starlette applications with Uvicorn managed by Gunicorn. The image includes auto-tuning of worker processes based on CPU cores. However, the project is explicitly deprecated in favor of using Uvicorn with the `--workers` option directly, as the need for Gunicorn as a process manager has been eliminated by recent Uvicorn features. The repository contains Dockerfiles for Python 3.10 and 3.11 (slim and non-slim) that build upon the `tiangolo/uvicorn-gunicorn` base image, and installs Starlette. It includes a minimal example application and tests to verify the image behavior.
This repository once contained Daytona, an open-source platform for running AI-generated code in secure, elastic sandboxes. According to the README, it provided isolated execution environments (sandboxes) with dedicated kernels, filesystems, and network stacks, accessible via SDKs in Python, TypeScript, Ruby, Go, and Java, as well as a CLI and REST API. The architecture was described as a multi-plane system with interface, control, and compute planes. However, the actual repository contents tell a radically different story from the README. The file tree contains only git internals, two logo image assets, and the README itself. There is no source code, no SDKs, no server implementation, no configuration files, no package manifests, no tests, and no build scripts. The README references directories like `libs/sdk-python`, `libs/sdk-typescript`, and many others, but none of them exist in this tree. The README is effectively a ghost document describing a product that has been entirely removed from this repository. The README explicitly states that as of June 2026, core development has moved to a private codebase and this repository will receive no further updates. With zero source code present and an explicit deprecation notice, this repository is a hollow shell — a README and logos with no implementation to analyze.
This repository has been wiped and replaced with a legal notice regarding copyright infringement. The sole remaining content is a README.md and an accompanying image, both serving as a public declaration that the project was deleted due to legal action and a warning to others to cease related infringing activities. There is no application code, data, or functional software present in the repository. Any historical utility the repository once provided is entirely gone, and the project is explicitly deprecated by its maintainers due to legal intervention.