This repository provides a comprehensive implementation of crystal plasticity finite element (CPFE) constitutive models as Abaqus user subroutines (UMAT and UEL). Core capabilities include slip-based plasticity for FCC, BCC, HCP, and alpha-uranium crystal structures; multiple hardening laws (Voce, Kocks-Mecking, linear, substructure); creep and irradiation damage; geometrically necessary dislocation (GND) density evolution via four distinct models; backstress (Armstrong-Frederick and non-local); and a dislocation-source-controlled model. A cohesive zone model (UEL) supports mixed-mode fracture with Benzeggagh-Kenane damage evolution. Pre-processing scripts convert microstructures from Dream3D and Neper into Abaqus input files. The code is modular, with separate Fortran modules for each physical process (slip, hardening, CRSS, irradiation, backstress, utilities), and can be adapted to polycrystal and single-crystal simulations. The repository also includes example cases (bicrystal CZM, polycrystal with PROPS, residual deformation, single crystal with voxel file) and documentation. While the codebase is actively maintained and well-suited for academic research in micromechanics, it exhibits duplication across example directories and some hardcoded paths, indicating a research-grade rather than production-grade maturity.
E-RayZer is a self-supervised 3D reconstruction / spatial visual pre-training research codebase. In practice, it takes unordered multi-view RGB images, estimates camera poses via a transformer-based PoseEstimator, constructs a per-pixel 3D Gaussian scene representation, and renders novel views via differentiable Gaussian splatting (gsplat). The repository includes a Gradio demo, a reusable inference engine, training/evaluation drivers for the DL3DV dataset, and benchmark split tooling for ScanNet++ and BlendedMVS. The code is organized into model modules (transformer encoder/decoder, pose estimator, Gaussian upsampler/renderer), utility layers (camera geometry, loss functions including VGG19 perceptual loss), and data-preparation scripts (Hugging Face downloader, OpenCV list conversion, covisibility/DINOv2 statistics, manifest checking). Training uses curriculum view selection, mixed precision, DDP, gradient accumulation, and configurable loss composition; evaluation reports PSNR and pose RPA metrics. Although the dominant character is research/data engineering, the repo is hybrid: it ships application-style entry points (gradio_app.py, app_core/engine.py) as well as data pipelines and model training scripts. The public training path is limited to DL3DV; the ScanNet++ and BlendedMVS benchmark scripts are historical protocol references that rely on internal S3 tooling. Reproducibility is moderate: DL3DV setup is documented and scripted, but the custom CUDA renderutils plugin, third-party gsplat submodule, external VGG weights, and curated download URLs make the environment fragile. Model weights are separately licensed under Adobe's non-commercial research license, while code is MIT.
This repository is the companion code and documentation for the JoyRL Book, a Chinese-language reinforcement learning textbook. It contains over 30 self-contained Jupyter notebooks implementing classic and modern RL algorithms (DQN, Double DQN, Dueling DQN, Noisy DQN, PER DQN, Categorical DQN, Rainbow DQN, REINFORCE, A2C, PPO, DDPG, TD3, SAC, TRPO, ACER, CQL, etc.) on Gymnasium environments like CartPole-v1, Pendulum-v1, and Acrobot-v1. The site is built with Docusaurus and includes interactive playgrounds (e.g., DQN Playground), visitor tracking via a Cloudflare Worker, and extensive pseudocode in LaTeX. The code is educational: each notebook is self-contained with model, replay buffer, policy, training loop, and plotting utilities. There is heavy code duplication across notebooks, no shared library, and no unit tests, but the implementations are correct and well-documented for learning purposes. The repository also includes documentation on offline RL and LLM+RL (placeholders).
The Open Cookie Database is a community-curated reference dataset cataloging HTTP cookies. The single source of truth is open-cookie-database.csv, which records each cookie's platform, category (Functional, Personalization, Analytics, Marketing, Security), cookie name/pattern, domain, description, retention period, data controller, GDPR/privacy policy URL, and a wildcard-match flag. The dataset is maintained through manual PR-based contributions following a documented research workflow, and it is consumed by downstream privacy tooling (notably the EU EDPB Website Auditing Tool, via a dedicated EDPB JSON export). A static HTML viewer renders the CSV client-side using PapaParse and DataTables for browsing and export. The data lineage is simple and fully automated: on every push touching the CSV, GitHub Actions runs validate.py (UUID format/uniqueness, category whitelist, duplicate detection), then regenerates two derived artifacts - open-cookie-database.json (records grouped by platform) via convert_csv_to_json.py, and open-cookie-database-edpb.json via convert_edpb.py, which maps the flat CSV onto the EDPB tool's nested knowledge-base JSON schema. The pipeline is deterministic, idempotent, and commits the regenerated JSON back to the repo when changed. There is no application runtime, API, or library; the three Python scripts and CI workflows are infrastructure that exists solely to keep the dataset valid and in sync across formats. Craftsmanship is functional but modest. The scripts show reasonable engineering discipline: CLI parameterization, graceful handling of missing/empty files, GitHub Actions error annotations, and non-zero exit codes on failure. The validation script encodes real data-quality rules. However, there are clear signs of aging: the HTML viewer references the retired StackPath Bootstrap CDN and contains a malformed protocol-relative script URL ('//http://...'); the main validation workflow still pins Node 16 (EOL) and uses checkout@v2; convert_edpb.py uses the deprecated datetime.utcnow(); and pandas is installed unpinned. These issues do not break the core CSV-to-JSON pipeline, but they make the supporting surface fragile. The repository is a data asset first and code second - the value lies in the curated cookie catalog and the governance around it, not in the software. It is a solid, genuinely useful open-data project with competent but unremarkable data engineering. An analyst can clone it and reproduce all derived JSON artifacts with just Python and pandas, since the dataset is bundled and the transforms are simple, explicit, and parameterized.
opengeos/lidar is a scientific Python library and GIS toolset for delineating nested surface depressions and mounts in digital elevation models (DEMs), with a heavy focus on LiDAR-derived high-resolution terrain data. The core engine implements a level-set method for extracting depression hierarchy, computing geometric attributes such as area, volume, depth, perimeter, and shape metrics, and exporting results as GeoTIFFs, shapefiles, and CSV tables. The package exposes a Python API (MedianFilter, ExtractSinks, DelineateDepressions, DelineateMounts), a PySimpleGUI-based GUI, a placeholder CLI, and an ArcGIS ArcMap/Pro toolbox with scripts for sink extraction, catchment delineation, flow path analysis, and inundation simulation. It also includes data acquisition utilities for USGS NED, 3DEP, and HUC8-based batch processing, plus LiDAR LAS/LAZ reading and DSM generation helpers.
This repository is a research and benchmarking project, not a runnable application. Its primary purpose is to systematically quantify the performance costs of Rust's safety features relative to C/C++ and to document the strongest and weakest aspects of Rust code generation. The main artifacts are structured survey/analysis documents under features/, benchmark harnesses that build and run real-world Rust projects (zed, bevy, uv, tokio, regex, veloren, etc.) under modified compiler branches, custom LLVM IR counting tools, and Python scripts that normalize, compare, and plot benchmark results. It is classified as data_research because the executable code is research infrastructure rather than a product, though it has hybrid aspects of a software benchmarking harness.
This repository is an educational tutorial for single-cell sequencing analysis best practices using Python. It provides a structured series of Jupyter notebooks and documentation covering preprocessing, quality control, normalization, feature selection, and advanced topics like trajectory inference and multi-modal data analysis. The tutorial uses real-world example datasets (e.g., 10x Multiome) and emphasizes reproducible workflows with AnnData and MuData objects, leveraging libraries such as scanpy, omicverse, and scverse tools. While primarily educational, it demonstrates standard data analysis patterns that can be adapted for similar single-cell projects.
This repository is a high-frequency trading (HFT) research and development framework, primarily written in Java with a significant Python layer for reinforcement learning and data analysis. The actual system provides a modular architecture for backtesting and live execution of algorithmic trading strategies across multiple exchanges (Binance, Interactive Brokers, Kraken, MetaTrader). It supports market making algorithms (Avellaneda-Stoikov, ConstantSpread), factor investing, and a wide range of execution algorithms (TWAP, VWAP, Implementation Shortfall). Reinforcement learning integration is a key feature, with Gymnasium environments communicating via ZeroMQ to Java-based RL agents. The data pipeline ingests tick-level depth and trade data from Parquet/CSV files or live streams, generates OHLCV candles, and feeds into both traditional backtesting and RL training loops. While the framework is functionally rich and demonstrates advanced patterns (Disruptor ring buffers, object pools, time-series utilities), the codebase suffers from maintenance drift: many third-party libraries are vendored or outdated, hardcoded paths are scattered, and several modules contain commented-out or incomplete code. The project is a hybrid of a production-like trading engine and research code, with the dominant character being an application framework for algorithmic trading research.
This is a single-file Obsidian plugin (TypeScript) that automatically persists and restores the cursor position, selection, and scroll offset for every markdown note in a vault. The core logic in main.ts hooks into Obsidian's workspace events (file-open, quit, rename, delete) and uses a polling interval (every 100ms) to detect cursor/scroll changes without relying on global key events. State is stored in a JSON file (configurable, defaults to the plugin directory), with settings for default position on open, save cadence, and pruning rules for orphaned, stale, or excessive entries. The plugin deliberately avoids scrolling when opening a note via a section link by detecting the Obsidian 'is-flashing' CSS marker. Architecturally it is a classic Obsidian plugin: an ES module compiled via Rollup into a single CommonJS bundle, with the settings UI built from the modern SettingGroup API requiring minAppVersion 1.11.0. The main implementation concentrates all feature logic in one 500-line class, relying on Obsidian's private/unstable APIs (marked with @ts-ignore) to read scroll positions and leaf IDs. Data flow is strictly in-memory + async JSON file writes: the path is read from disk at load, pruned, and periodically flushed on a timer (minimum 5s) and on quit. This is not a hybrid research repo; it is a dedicated end-user application plugin. The workmanship exceeds typical plugin boilerplate: the state-comparison logic avoids redundant writes, the pruning layer handles three independent criteria, and the footnote-detection heuristic for the 'before footnotes' option is a genuinely non-obvious feature. However, it is held back by a monolithic design (one giant class), a polling loop instead of event-driven cursor capture, multiple @ts-ignore workarounds against stale Obsidian internals, and a dependency list that is several major versions behind its ecosystem.
This repository is a curated collection of skill plugins for AI coding agents such as Claude Code, Codex, and Cursor. Each skill is a self-contained directory with a SKILL.md descriptor, executable scripts, reference documents, and templates. The ecosystem covers a wide range of capabilities: multi-provider media generation (images, video, audio), browser automation via CDP, macOS app telemetry auditing, document format replication, open-source preparation (secret scanning, license generation), Cloudflare Workers deployment, trend aggregation, and video processing. The skills are designed to be invoked by an AI agent reading the SKILL.md and executing workflows via CLI scripts. While primarily an application-oriented collection, some skills (e.g., happy-app-audit) incorporate data analysis and reverse-engineering methodology, giving it a hybrid character. The architecture is modular: each skill is independent, with consistent patterns for provider abstraction, async polling, and template-based output. This makes the repository a practical toolkit for extending agent capabilities rather than a standalone production service.
This repository is the Dawn theme for Ghost CMS (version 5+), providing a complete front-end presentation layer for a Ghost publication. It is a static theme built with Handlebars templates, PostCSS for styling, and jQuery-based JavaScript for interactivity (featured carousel, lightbox, pagination, responsive menus). The architecture follows Ghost's standard theme structure with layouts (`default.hbs`), content templates (`post.hbs`, `page.hbs`, `tag.hbs`, `author.hbs`), and partials for reuse. A Gulp-based build pipeline processes CSS (via PostCSS with autoprefixer and cssnano), bundles and minifies JavaScript, merges translation files, and produces a zip package for deployment. The theme supports dark mode via CSS custom properties, multiple social icon partials, infinite scroll pagination, PhotoSwipe image galleries, and member-only content paywalls. The codebase is well-organized with modular CSS imports and clear separation of concerns between layout, components, and utilities. The JavaScript (minified as `main.min.js`) integrates Owl Carousel for featured posts, intersection-observer-based pagination, and custom dropdown logic. While the theme relies on older libraries (jQuery 3.5.1, Owl Carousel 2.3.4, PhotoSwipe 4.1.3), the implementation itself is solid and follows Ghost theme best practices. The build pipeline is standard but functional, and the theme passes `gscan` validation in CI. The main risks are dependency drift (no lockfile, monorepo sync issues) and reliance on aging jQuery-based plugins, but for a content-focused theme it remains a professional and feature-rich solution.
pyalgotrading is a Python library that provides an interface to the AlgoBulls algorithmic trading platform. It enables users to create, upload, and execute trading strategies for backtesting, paper trading, and live trading. The library includes abstractions for strategies, orders, and technical indicators, along with an API client for communicating with the AlgoBulls platform. Users define strategy classes that inherit from StrategyBase, implement required methods, and then use the AlgoBullsConnection class to deploy and manage their strategies on the platform. The library supports multiple order types, technical indicators via TA-Lib, and various candlestick chart formats.
Automation Gateway is a reactive, configuration-driven bridge for industrial protocols (OPC UA, MQTT, PLC4X) that routes real-time process data to multiple time-series databases (InfluxDB, IoTDB, OpenSearch, Cassandra, PostgreSQL, etc.) and exposes it via GraphQL, MQTT, and OPC UA servers. The system runs as a single JVM or GraalVM native binary, orchestrated through YAML configuration files that define driver instances, logger sinks, and server endpoints. Its core architecture is built on Vert.x event bus for internal pub/sub messaging, with abstract base classes (DriverBase, LoggerBase) enabling consistent extension for new protocols or data stores. The gateway does not persist data itself; it acts as a real-time router with configurable buffering and queue reliability (memory-mapped disk queue). Key entry points include `App.kt` for the main application and `GraphQLServer.kt` for the administrative API, which supports JWT authentication, health checks, and dynamic component management. External dependencies include Eclipse Milo (OPC UA), HiveMQ MQTT client, PLC4X, Apache IoTDB Thrift, InfluxDB HTTP client, and various database drivers. The codebase is mature (v1.38) with active development, but carries some technical drift in the form of deprecated features still present in source code and a large set of reflection configurations for GraalVM native-image that require careful maintenance.
This repository is an unofficial fork of J2ME-Loader, a Java ME (J2ME) emulator for Android. It enables running MIDlets (Java ME applications) on Android devices by implementing J2ME APIs (LCDUI, M3G, MMAPI, etc.) and using native C++ components via JNI for performance-critical sections like 3D rendering (M3G) and audio synthesis (Sonivox, TSF). The emulator includes a user interface for browsing and launching MIDlets, configuring settings, and handling permissions. It also features a dex manipulation library (dexlib) for processing DEX files to ensure compatibility with Android ART. While the emulator is functional and demonstrates solid engineering practices, it shows signs of technical drift due to deprecated Android APIs and a forked dex library that may lag behind upstream, and maintenance appears stale based on commit frequency.
FlyDangerous is a Unity-based space flight game featuring multiple game modes such as time trial, free roam, and multiplayer. The game includes a variety of ships (like the Puffin and Calidris) and procedurally generated tracks with different themes. It integrates Steamworks for online leaderboards and multiplayer, and uses the Mirror networking library for multiplayer functionality. The project also incorporates custom UI elements and supports haptic feedback via Bhaptics. The architecture follows a modular structure with separate concerns for core game systems, gameplay mechanics, user interface, and networking. Key systems include a custom input processor suite, a flexible UI framework (FdUI), and an abstraction layer for online services that allows swapping between different backend implementations (e.g., Steam). The game leverages Unity's new Input System and includes various visual and audio enhancements. While the codebase demonstrates solid engineering practices in certain areas—such as the online services abstraction and custom UI controls—it shows signs of technical drift due to bundled dependencies and potential use of outdated third-party libraries. The repository appears to be stale, with no recent commits evident from the provided data, and a high number of open issues suggesting possible maintenance challenges.
This repository provides an automated system for setting up a VirtualBox VM running Ubuntu 7.10 that hosts the Open Genera 2.0 Lisp machine environment. It uses veewee to create a base box, Vagrant to manage the VM lifecycle, and shell scripts to install required packages, configure network services (NFS, inetd), set up the Lisp machine software, and launch a VNC server for user interaction. The system is intentionally designed to use an old Ubuntu version due to specific X11 requirements of the Lisp machine emulator. The architecture follows a standard provisioning workflow: dependency verification → base box creation → VM provisioning → application-specific configuration. Key entry points include the Makefile (orchestrating the overall process), Vagrantfile (defining VM properties), and provision.sh (handling the majority of setup tasks). The system demonstrates good practices in idempotent operations, dependency checking with helpful error messages, and clean separation of concerns. While highly specialized for this particular legacy software environment, the repository contains several well-executed patterns that could be adapted elsewhere: the VNC startup script shows proper technique for configuring X resources, remapping keys, and launching applications in a VNC session; the provisioning script demonstrates idempotent setup patterns; and the Makefile provides a reusable model for dependency verification and step-by-step orchestration of complex setup procedures.
Jaxformer is a JAX-based library for training large language models (LLMs) on TPUs with data and model parallelism. It provides a complete training loop supporting distributed training across TPU cores, checkpointing, and resumable data loading from TFRecord files. The codebase includes model definitions for transformer-based architectures (like CodeGen), utilities for learning rate scheduling and optimization, and integration with Hugging Face for model conversion and sampling. The system is designed for scalability, supporting models up to 6B parameters via sharding strategies, and includes tools for preprocessing large datasets into TFRecord format. While the core training functionality is tightly coupled to the TPU environment, several components like the resumable data iterator and checkpointing mechanism demonstrate reusable patterns.
Supervizer is a Node.js process manager that provides CLI and RESTful API interfaces for spawning, stopping, and managing Node.js applications. It follows a client-server architecture where the supervizer-client communicates with a supervizer-server via HTTP to manage application processes. The server maintains application state in memory, supports process monitoring, file watching for automatic restarts, grouping of applications, and secure authentication. Key features include keeping applications alive on crash, resource monitoring (CPU/memory), log and PID file management, and JSON-based configuration persistence.
Apache KIE Examples is a curated monorepo of runnable example applications for the Kogito platform, which unifies Drools rules, jBPM processes, DMN decisions, and PMML predictions into cloud-native services. The repository contains 100+ standalone Maven and Gradle modules, each a self-contained Quarkus or Spring Boot microservice demonstrating a specific Kogito capability: BPMN process orchestration with user tasks and timers, DMN decision tables, DRL rule units, PMML scoring, Kafka/CloudEvents event-driven flows, transactional outbox with Debezium, persistence via MongoDB/PostgreSQL/Infinispan, Keycloak OIDC security, Prometheus/Grafana monitoring, and OpenShift/Kubernetes deployment. The dominant pattern is parallel Quarkus and Spring Boot implementations of the same example, plus Gradle build variants, so engineers can compare runtime behavior across stacks.
Tina is a header-only library providing lightweight user-space threading through coroutines and fibers, along with a fiber-based job system for task scheduling. The core library (tina.h) implements symmetric and asymmetric coroutine APIs with platform-specific assembly for context switching. Tina Jobs (tina_jobs.h) builds on this to create a job scheduler featuring work-stealing via queue chaining, memory pooling, and fiber-based job execution to avoid OS thread overhead. The repository includes examples (e.g., Mandelbrot renderer using Sokol graphics) and tests demonstrating usage, but the project has migrated to Codeberg due to philosophical opposition to AI training, indicating the GitHub repository is no longer actively maintained. While the Sokol dependencies in extras are third-party, the Tina core showcases strong craftsmanship in low-level concurrency primitives.