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).
Hey is a decentralized social media application built on the Lens Protocol. It provides a full-featured frontend for users to interact with the Lens blockchain, including wallet authentication, post creation and engagement (likes, comments, reposts, collects, tips), group management, notifications, and profile customization. The application uses React 19 with Vite for bundling, TypeScript for type safety, and Tailwind CSS for styling. State management combines Apollo Client for GraphQL data persistence with Zustand stores for client-side state (account, notifications, preferences). Key architectural patterns include optimistic UI updates for blockchain transactions, portal-based modals, and custom hooks for transaction handling and media uploads. The codebase demonstrates strong modularity with reusable UI components and clear separation between UI, state management, and data layers.
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.
Nextcloud Social is a federated social networking application implemented as a Nextcloud app. It allows each Nextcloud user to become an ActivityPub actor (Person), enabling posting, following, liking, boosting, replying, and direct messaging across the Fediverse. The system is fully compatible with the Mastodon client API, supporting timelines, lists, filters, scheduled posts, polls, stories, collections, trends, and moderation features. The backend is written in PHP, structured with controllers, services, database request builders, and ActivityPub model classes. The frontend is built with Vue 3, Pinia, and Vue Router, providing a responsive single-page application for timelines, profiles, and settings. The app integrates deeply with Nextcloud's dashboard, notifications, search, user migration, and admin settings. Federation is handled via ActivityPub protocols with HTTP signature verification, outbound delivery queues, and WebFinger discovery. The codebase is well-tested with both PHPUnit and Vitest suites, covering unit, integration, and federation wire compatibility tests.
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.
Jumble is a full-featured Nostr client for exploring relay feeds and engaging with the nostr social protocol. It is built as a Progressive Web App (PWA) with an optional Electron desktop wrapper, offering a rich set of features including notes, reactions, zaps, encrypted direct messages (NIP-17/NIP-4e), relay management, custom emoji packs, long-form articles, polls, media upload (Blossom/NIP-96), and translation services. The architecture is a React 18 + TypeScript single-page application with Vite as the build tool, using state management via React Context and service singletons with IndexedDB/localStorage persistence. The desktop variant adds native secret storage, auto-updater, and a custom media server. The codebase demonstrates high craftsmanship in areas such as relay connection management (SmartPool/ElectronPool with retry and health checks), an LRU-based caching abstraction (BoundedMap), a robust content parser, and a well-structured draft event creation pipeline. However, it also exhibits some monolithic services and tight coupling across providers, which limits modular reuse. Overall, it is a mature, production-grade implementation of a decentralized social media client with active development and a broad feature surface.
PaoPao-ce is a full-stack micro-community social media platform written in Go (backend) and Vue 3 (frontend). It provides a feature-rich experience similar to Twitter/Weibo, including posts (tweets) with multimedia attachments, comments, likes, collections, private messaging, user profiles, topic/tag support, and a wallet system with Alipay integration. The architecture is modular and configurable, supporting multiple databases (MySQL, PostgreSQL, SQLite), search engines (Meilisearch, Zinc), object storage backends (LocalOSS, MinIO, AliOSS, COS, Huawei OBS, S3), caching layers (Redis, BigCache), and observability tools (OpenTelemetry, Sentry, Pyroscope, pprof). The backend uses Gin for HTTP, GORM for ORM, go-mir for API code generation, and protobuf for gRPC services. The frontend is built with Vue 3, Naive UI, Vite, and Pinia. Key features include feature toggles for different deployment suites, a runtime settings override via admin UI, and background job processing for search indexing and metrics. The platform emphasizes self-hosting and customization, with comprehensive SQL migration scripts and support for desktop clients via Tauri. The codebase demonstrates solid engineering practices with interface-based dependency injection, layered architecture, and code generation, though it carries some technical debt from deprecated backends and WIP features.
This is a self-hosted social timeline application (moments/朋友圈) that allows users to post short updates (memos) with rich media: images, videos, music, links, and Douban (Chinese media database) book/movie references. The architecture is a single Go binary that embeds a Nuxt.js static frontend and connects to a SQLite database. The backend provides a REST API with JWT authentication, supports file upload (local or S3), comment system with email notifications, RSS feed generation, and database backup on version changes. Noteworthy features include automatic database backup with cleanup, image thumbnail generation, Google reCAPTCHA integration, and a calendar-based search for memos. The codebase is well-organized with dependency injection (samber/do), proper route grouping, and data migration scripts. The frontend is a Nuxt 3 SPA with Tailwind CSS and component-based UI. The project is actively maintained with frequent commits and a responsive issue tracker.
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.
The repository is an MCP (Model Context Protocol) server designed to interact with Xiaohongshu (Little Red Book) social media platform. It exposes a set of tools via the MCP standard that enable AI assistants to perform actions like checking cookie validity, retrieving home feed, searching notes, fetching note content and comments, and posting comments. The server requires a valid Xiaohongshu cookie obtained from web login for authentication. Architecturally, the application follows a modular design separating the MCP transport layer (implemented using FastMCP in `xhs_mcp/__main__.py`) from the business logic handled by API clients. Two API implementations exist: the original (`xhs_mcp/api/xhs_api.py`) uses curl_cffi and execjs to reverse-engineer and execute JavaScript for generating required anti-bot signatures (X-S, X-T headers), while the v2 version (`xhs_mcp/api/xhs_api_v2.py`) employs Playwright for JavaScript execution in a browser context. The MCP server dynamically registers tools from these API modules, manages server lifecycle with proper resource cleanup, and handles authentication errors by prompting cookie validation. The project demonstrates solid engineering practices with clear separation of concerns, async/await patterns for non-blocking I/O, and environment-based configuration for sensitive data. However, it faces inherent technical drift due to reliance on Xiaohongshu's private undocumented APIs, which are subject to frequent changes that break signature generation mechanisms. The dual API implementations indicate ongoing efforts to adapt to such changes, though they introduce maintenance overhead. Dependency management is modern using uv and Python 3.12, but version constraints (e.g., curl-cffi<0.14.0) may pose future compatibility risks.
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.
This repository contains the original open-source codebase for reddit, the social news aggregation and discussion platform. It is a monolithic web application built on the Pylons framework (Python 2), serving both a server-rendered frontend (Mako templates, jQuery, Backbone) and a REST-like API. The architecture relies on multiple data stores: PostgreSQL for core entities (things), Cassandra for high-write data (votes, comments trees, view counts), Memcached/McRouter for caching, and RabbitMQ for asynchronous job processing. It includes a full advertising system, user awards/gold, moderation tools, a wiki, and traffic analytics. While the codebase is archived and relies on heavily outdated dependencies (Python 2, Pylons, pycassa), it showcases several well-designed internal patterns such as a pluggable provider system, a layered cache chain with stale-while-revalidate, and a feature flag framework for A/B testing. These components demonstrate non-trivial engineering skill and could be extracted for reuse. However, the vast majority of the codebase is tightly coupled to reddit-specific models and global state, limiting reusability without significant adaptation.