This repository is a high-performance React Native camera library (VisionCamera) that provides photo/video capture, real-time frame processing, barcode scanning, location tagging, and GPU-accelerated frame resizing. It is organized as a monorepo with a core package and several plugin packages (barcode-scanner, location, resizer, skia, worklets). The architecture uses NitroModules to generate C++/Swift/Kotlin hybrid object bridges, enabling zero-copy data flow from platform camera APIs (AVFoundation on iOS, CameraX on Android) to JavaScript. Key entry points include the `<Camera>` React component, hooks like `useCameraSession`, `useFrameOutput`, `useBarcodeScannerOutput`, and factory functions for creating sessions and outputs. External dependencies include platform camera frameworks, ML Kit for barcode detection, CoreLocation for geotagging, and Metal/Vulkan for GPU compute. The library is production-grade, used by major apps (Amazon, Shopify, Tesla, etc.), and features a constraint resolution system for optimal format selection, gesture controllers for zoom and tap-to-focus, and a worklet runtime for offloading frame processing to native threads.
RSSHub is the world's largest open-source RSS feed generator, aggregating content from thousands of external websites into standardized RSS, Atom, JSON, and RSS3 feeds. It is a TypeScript application built on the Hono web framework, with a modular architecture where each source (news site, social platform, university notice board, government agency, etc.) is implemented as a self-contained 'route' module that fetches pages or APIs, parses HTML with Cheerio, and optionally renders rich descriptions using JSX. The project supports multiple deployment targets including Node.js, Docker, Vercel, and Cloudflare Workers, and integrates caching (Redis/LRU), middleware for access control, ETag/conditional requests, error tracking (Sentry, Honeybadger), and anti-hotlinking. The codebase is highly organized with consistent route definitions, extensive utility functions (date parsing, HTTP caching, header generation), and a strong emphasis on type safety. While the sheer volume of routes (thousands) introduces maintenance burden and some inconsistency (legacy `got` vs modern `ofetch`), the overall architecture is clean, well-tested for core infrastructure, and exhibits strong engineering practice. This is not a data-research repository; it is a production-grade web service for feed aggregation.
Cobalt is a privacy-focused media downloader web application with a SvelteKit frontend and Node.js/Express API backend. Users paste a URL from supported platforms (YouTube, TikTok, Instagram, Twitter/X, Vimeo, Reddit, SoundCloud, Twitch, Bilibili, and 15+ others) and receive a downloadable media file. The architecture is a monorepo with three packages: @imput/cobalt-web (static frontend), @imput/cobalt-api (processing backend), and @imput/version-info (build-time version helper). The API acts as a fancy proxy - it fetches media streams from source platforms, optionally remuxes/transcodes via FFmpeg (server-side or client-side via libav.js WebAssembly), and streams results back without ever writing to disk. The frontend handles URL input, settings management (localStorage with migration), a processing queue with Web Workers for client-side FFmpeg, i18n (EN/RU), and PWA features. Key data flows: user submits URL → API validates/matches service → extracts stream URLs → returns tunnel/redirect/picker response → frontend either streams directly, proxies via API, or processes locally via Web Workers. External dependencies: FFmpeg (via ffmpeg-static), youtubei.js for YouTube, hls-parser, undici for HTTP, Redis (optional for rate limiting), Cloudflare Turnstile (optional bot protection).
Uppy is a modular, client-side JavaScript file upload library with a companion server (Companion) for remote provider integrations. It provides a plugin-based architecture where core functionality (file selection, upload strategies, UI components) is encapsulated in reusable packages. The client-side library supports drag-and-drop, webcam/screen capture, image editing, thumbnail generation, and multiple upload backends (tus resumable, AWS S3 multipart, XHR, Transloadit). The Companion server handles OAuth flows, remote file listing/download from providers like Google Drive, Dropbox, Box, OneDrive, Facebook, Zoom, Unsplash, and WebDAV, as well as S3 presigning and Transloadit Storage integration. The repository is a monorepo with over 50 packages, including framework-specific wrappers for React, Vue, Svelte, and Angular, plus headless controllers for custom UI. Key entry points are @uppy/core (Uppy class, plugin system), @uppy/dashboard (main UI), @uppy/companion (Express server), and @uppy/aws-s3 (S3 upload client). Data flows: user selects files via UI plugins, which are then uploaded via configured uploader plugins; remote sources are fetched through Companion using OAuth tokens. External dependencies include tus-js-client, AWS SDK, Transloadit API, and various OAuth providers. The codebase is well-tested with unit, integration, and browser tests, and uses modern TypeScript, ESM, and Preact for UI.
This is a mature, actively maintained AI agent skill called 'last30days' that enables agents (Claude Code, Codex, Grok, Gemini CLI, MCP hosts) to research any topic by aggregating content from 20+ social and news platforms (Reddit, X, YouTube, TikTok, Instagram, Hacker News, Polymarket, GitHub, arXiv, Techmeme, Digg, and more) over a rolling 30-day window. The system is primarily a CLI engine (Python) with a companion Go MCP server for Claude Desktop. It employs a sophisticated pipeline: query planning by intent, parallel retrieval from multiple backends (keyless APIs, paid scrapers, CLI tools, LLM-based search), source-specific normalization, engagement-weighted relevance scoring, cross-source clustering, and deterministic fusion (weighted RRF) with per-author caps and diversity floors. Output is rendered as structured JSON, compact text, or self-contained HTML with optional publishing and Atom feeds. The codebase emphasizes security (credential hygiene, no browser cookie reads in unattended mode), determinism (fixture-based evaluation harness with grounding/recency/coherence scores), and graceful degradation (per-source fallback chains, never-raise error envelopes). While classified as an application (it's a skill/plugin for agent hosts), it exhibits strong data engineering traits: source adapters, normalization pipelines, scoring models, and an offline evaluation framework.
The Social Media Hacker List repository primarily maintains a curated markdown list of tools and applications for enhancing social media experiences across various platforms (Facebook, Instagram, Twitter, etc.). The list is organized by platform and includes entries such as alternative clients, analytics tools, bots, and content creation utilities. Each entry is manually curated and must meet specific inclusion criteria, such as being created by unaffiliated developers and having recent activity. To ensure the list remains accurate and free of broken or inactive links, the repository includes a Rust-based URL checker application. This tool is executed weekly via a GitHub Actions workflow (check.yaml) to validate every URL in the README.md. For standard URLs, it performs HEAD and GET requests, treating certain HTTP status codes as success (200, 403, 406) with special handling for known edge cases (e.g., 502 for reddit.com, 429 for apps.apple.com). For GitHub repository URLs, it uses the GitHub API to check if the repository is archived or has not been pushed to in the last 365 days, flagging such entries as invalid. The checker application is designed as a standalone, concurrent command-line tool. It reads input from stdin, extracts URLs using a regular expression, and processes them asynchronously with the tokio runtime. The application is containerized via a multi-stage Dockerfile and published to GitHub Container Registry through another workflow (publish.yaml), allowing it to be reused in other contexts. The code demonstrates solid Rust practices, including proper error handling, asynchronous I/O, and modular function design, making its core URL and GitHub checking logic potentially reusable in other projects with minimal adaptation.
This is a monorepo housing two terminal-based Instagram clients: a modern TypeScript client using React Ink for a rich Terminal User Interface (TUI) and a legacy Python client using curses. The system provides a full-featured Instagram experience entirely within the terminal, including real-time messaging via MQTT, feed and story browsing, profile viewing, multi-account management, authentication (with 2FA/challenge support), and one-turn CLI commands for AI agent integration. It also incorporates LLM-based chat summarization (OpenAI compatible) and basic analytics in the Python client. Architecture is straightforward: a CLI entry point (Pastel for TS, Typer for Python) dispatches commands, with the TUI built from reusable Ink components (ScrollView, MessageList, InputBox, etc.) that manage state via React hooks and contexts. A mock system enables offline UI development. External dependencies include reverse-engineered Instagram APIs (instagram-private-api, instagram_mqtt) and multiple utility libraries. The dual-client structure and reliance on patched, unofficial APIs introduce maintenance risks, but the TypeScript client is well-crafted with clear separation of concerns, thorough component reuse, and thoughtful UX design for keyboard-driven terminal use.
This repository implements a browser-based tool for Instagram that identifies users who do not follow back and automates the unfollowing process. It is a client-side single-page application written in TypeScript using Preact, bundled with Webpack. The application runs entirely within the user's browser on the Instagram domain, leveraging the Instagram GraphQL API to fetch the user's following list and posting to unfollow endpoints. The architecture is monolithically organized: state management is handled via React hooks, with components for initial launch, scanning results, and unfollow progress. Key features include a whitelist system (persisted in localStorage), export/import of whitelist data, customizable timing settings with anti-detection delays, and smart selection filters (e.g., select verified, private, no profile pic). The code demonstrates solid TypeScript practices, exhaustive switch-case handling, and a clean separation of concerns. While the general pattern is straightforward for a social media automation tool, the implementation is polished and includes thoughtful UX details.
PhotoEditor is an Android library (published on Maven Central) that provides a comprehensive image editing SDK. It allows users to draw on images with customizable brushes and shapes (line, oval, rectangle, arrow), apply filter effects via Android's deprecated MediaEffect API, add and edit text with rich styling (color, font, shadow, border), insert emoji and stickers, and perform pinch-to-scale/rotate gestures on added elements. The library is built around a `PhotoEditorView` custom RelativeLayout that composes an ImageView, a DrawingView (custom canvas for brush/shape rendering), and an ImageFilterView (GLSurfaceView for filters). The architecture employs several design patterns: Builder (PhotoEditor, ShapeBuilder, TextStyleBuilder, SaveSettings), Composite (Graphic interface with Text, Sticker, Emoji implementations), Strategy (Shape interface with concrete shapes), and Listener (OnPhotoEditorListener, BrushViewChangeListener). The sample app demonstrates all features. The library has a robust undo/redo system managed by GraphicManager and PhotoEditorViewState. While the core functionality is solid, the filter implementation relies on deprecated Android APIs (android.media.effect), which is a known limitation and source of issues. The codebase is well-structured with unit and instrumentation tests, CI/CD pipelines, and proper Kotlin coroutines for async saving.
YPImagePicker is an iOS framework that provides an Instagram-like photo and video picker with a rich set of features including camera capture, library browsing, video trimming, photo filters, cropping, and multiple selection. The architecture follows a modular pattern with a central configuration struct (YPImagePickerConfiguration) that controls all behaviors, and a navigation controller (YPImagePicker) that manages a paged interface (YPPickerVC) switching between library, photo, and video screens. The library screen uses PHPhotoLibrary and PHCachingImageManager for asset fetching and caching, while the camera and video screens leverage AVFoundation for capture. Filters are applied via Core Image, and video trimming uses the PryntTrimmerView dependency. The framework is highly customizable through configuration properties for colors, fonts, icons, wordings, and feature toggles. The codebase is well-organized into folders for configuration, filters, helpers, models, pages (gallery, photo, video), and selections gallery. Helper extensions provide reusable functionality for AVFoundation, Photos, UIKit, and Core Image operations. The permission management is abstracted into a dedicated module. While the framework lacks unit tests and some view controllers are large, the overall structure is clean and the separation of concerns is reasonable. The library has been widely adopted (4.4k stars) and is actively maintained with recent commits and pinned dependencies.
This repository is a comprehensive, curated collection of step-by-step privacy configuration guides for a wide range of software, services, and operating systems (e.g., browsers, messaging apps, social media, Windows, Android, macOS). It is purely documentation—no executable code, APIs, or data pipelines. The content is organized into Markdown files under 'Privacy Settings' and 'Extensions Settings', with a central README serving as an index. The guides are consistently formatted, include notes and tips, and are actively maintained with regular updates reflecting the latest stable versions. While not a software application, it serves as a high-quality reference for users seeking to harden privacy settings across their digital footprint.
instagram4j is a Java library that provides an object-oriented interface to Instagram's private (undocumented) API. It supports both mobile and web API endpoints, allowing actions such as logging in with username/password or existing session tokens, fetching profiles, posts, stories, direct messages, searching, posting pictures, liking, commenting, following/unfollowing, and more. The library is structured as a multi-module Gradle project with separate 'mobile' and 'web' modules, each mirroring similar functionality but using different API endpoints (REST for mobile, GraphQL for web). It uses OkHttp for HTTP requests and a custom JSON library. The codebase demonstrates good engineering practices with clear separation of concerns, pagination iterators, and robust error handling. However, there is significant code duplication between the two modules, and the library relies on reverse-engineered endpoints that may break with Instagram updates. The last commit date appears to be in the future (2026), suggesting the repository may be stale or the timestamp is erroneous.
This is the OCA/social repository, a collection of 15 Odoo addon modules for Odoo 18.0 that extend the Odoo Discuss and mail systems with external messaging integrations and social profile features. The core module, `mail_gateway`, provides an abstract framework for integrating external chat platforms (Telegram, WhatsApp, Instagram) into Odoo Discuss via webhooks, enabling bidirectional communication. Concrete gateway modules (`mail_gateway_telegram`, `mail_gateway_whatsapp`, `mail_gateway_instagram`, and `mail_gateway_telegram_standalone`) implement provider-specific APIs, including message sending, template management (WhatsApp), and webhook verification. Additional modules add social media profile fields to partners and companies (LinkedIn, Mastodon), audit activity cancellations and unlinks, control mention suggestions, route unhandled emails to a default thread, and extend marketing campaigns with budget tracking. The repository follows standard OCA addon structure with Python models, XML views, OWL/JavaScript component patches, wizards, security rules, and translations. It is not a standalone application but a set of modules designed to be installed in an Odoo instance.
Reels-AutoPilot is a Python automation application that scrapes short-form video (Instagram Reels and YouTube Shorts) from configured creator accounts and reposts that content to the user's own Instagram account, including optional story cross-posting. The architecture is a small monolith of loosely coupled scripts sharing a SQLite database: app.py is the main orchestrator running an infinite scheduling loop, reels.py and shorts.py scrape content via instagrapi/yt-dlp, poster.py uploads clips and stories, remover.py purges posted files, and db.py/helpers.py provide SQLAlchemy persistence plus a config system where SQLite values override static defaults in config.py. A Rich-based terminal dashboard (dashboard.py) shows live posting status, and start.py is an interactive CLI setup wizard. The core data flow is: scrape → download to downloads/ → insert metadata row into the 'reels' table as unposted → poster loop picks the oldest unposted row → upload as an Instagram clip → mark posted → optionally trim to 15s and post as a story with mention/link/hashtag/media stickers → remover deletes the local file after a configurable interval. External dependencies are the unofficial Instagram client instagrapi, the YouTube Data API v3 with yt-dlp, moviepy for video trimming, SQLAlchemy, and Rich. The code is functional but rough: reels.py has a filter bug (a tuple instead of a boolean condition) that lets non-reel media into the database; dashboard.py compares string config values to integers so status toggles always render as 'Off'; start.py validates the wrong variable in two input loops; exceptions are silently swallowed; and Instagram credentials are stored in plaintext in both config.py and the SQLite DB, with database/sqlite.db committed to the repository (a credential-leak risk). There are no tests or CI, and the README advertises features (scheduling, multi-account, auto-hashtags, analytics) that do not exist in the code. Dependency versions are somewhat dated, with moviepy 1.0.3 (circa 2020) the most notable lag. The YouTube channel-resolution helpers and the instagrapi story-sticker composition are the most genuinely reusable pieces.
Instabot is a Python library and CLI tool for automating Instagram actions such as liking, commenting, following, unfollowing, uploading photos/videos, and direct messaging. It operates by reverse-engineering Instagram's private API, simulating an Android client with device fingerprints, session cookies, and request signing. The architecture consists of a low-level API wrapper (`instabot.api.API`) that handles HTTP requests and login flow, and a high-level Bot class (`instabot.bot.Bot`) that orchestrates actions with built-in rate limiting, filtering, and checkpointing. The repository includes over 30 example scripts for common automation tasks, a multi-script CLI menu, and a scheduled 24/7 bot. External dependencies include `requests`, `Pillow`, `moviepy`, and `pycryptodome`. The project is no longer actively maintained and carries high risk of Instagram account bans due to ToS violations. The README now promotes paid private API services, indicating the open-source codebase is effectively deprecated.