🌟 cursor/plugins caught my eye on GitHub Trending today.

🔗 https://github.com/cursor/plugins
📝 Cursor plugin specification and official plugins
──────────────────────────────

What is the cursor/plugins repository?
It is the official collection of Cursor plugins that extend the AI‑powered coding assistant with ready‑to‑use integrations for the most popular developer tools, frameworks, and SaaS products. Each plugin lives in its own folder and ships with a self‑contained .cursor-plugin/plugin.json manifest, so you can drop it into a Cursor workspace and start using it instantly.

Key features at a glance

Huge variety – from utility plugins like Teaching and Continual Learning, to dev‑ops helpers such as Cursor Team Kit and Thermos, all the way to productivity and SaaS connectors (Gmail, Google Drive, Salesforce, Zoom, etc.).
Marketplace‑ready – the root .cursor-plugin/marketplace.json indexes every plugin, enabling Cursor’s built‑in marketplace UI to discover, install, and update them automatically.
Modular architecture – each plugin contains:

plugin-name/
├── .cursor-plugin/
│   └── plugin.json        # plugin manifest
├── skills/                # SKILL.md files describing agent capabilities
├── rules/                 # .mdc rule files that shape the agent’s behaviour
├── mcp.json               # MCP server definitions (if needed)
├── README.md
├── CHANGELOG.md
└── LICENSE
    

Typed SDK support – the Cursor SDK plugin shows how to build custom scripts and automations with the TypeScript SDK.
Parallelism & orchestration – plugins like Thermos and Orchestrate let you fan out large tasks to multiple cloud agents, apply rubrics, and merge‑ready PR flows.
Open source & MIT licensed – you can fork, tweak, or contribute back without legal hurdles.


How to use a plugin
1. Open Cursor’s Marketplace panel.
2. Search for the desired name (e.g., gmail or pr-review-canvas).
3. Click Install; Cursor copies the plugin folder into your workspace and registers the manifest.
4. The plugin’s skills/ and rules/ are now available to the coding agent – you can invoke them with natural‑language prompts like “draft a reply to this email” or “run a security audit on the new branch”.
For developers who want to create their own plugin, the Create Plugin template provides a scaffold and a validation script that checks the manifest and required files before publishing.

Technical highlights

Manifest‑driven design – plugin.json declares capabilities, required permissions, and entry points, making the runtime discovery completely declarative.
Skill‑first approach – each plugin can ship one or more SKILL.md files with front‑matter that describes the agent’s “skill set”, enabling Cursor to surface contextual help and autocomplete suggestions.
Rule engine integration – .mdc rule files let you encode safety checks, style guides, or custom validation logic that the agent obeys automatically.
Multi‑agent orchestration – plugins such as Thermos and Orchestrate define planners, workers, and verifiers in mcp.json, allowing parallel execution and structured hand‑offs.
Third‑party connectors – OAuth handling, API wrappers, and UI components are baked into the SaaS plugins, so the agent can read/write Gmail, fetch Zoom transcripts, or update Salesforce records without extra code.


Who should explore this repo?
(1/2)

Cursor power users who want to supercharge their AI assistant with domain‑specific knowledge.
DevOps & SRE teams looking for automated code‑review, security audit, and CI pipelines.
Productivity hackers who wish to control email, calendar, and CRM directly from the editor.
Plugin developers interested in the manifest‑first pattern and the TypeScript SDK for building new integrations.


Quick start example (installing the Gmail plugin)

# Inside a Cursor workspace, open the Marketplace UI
# Search for "gmail" and click Install
# After installation, you can run:
cursor ask "Draft a reply to the last email from Alice about the Q3 budget."

Bottom line
The cursor/plugins repo is a plug‑and‑play ecosystem that lets you turn the Cursor AI into a full‑featured development assistant, a productivity hub, and a custom‑integration platform—all under an open‑source MIT license.

Turn a single AI into a whole team with just a click.

──────────────────────────────
🧠 Channel: https://t.me/GithubRe
(2/2)

🎯 santifer/career-ops landed on trending. Worth a proper look.

🔗 https://github.com/santifer/career-ops
📝 Open-source AI job search: scan job portals, evaluate listings with a structured A-F rubric into a 1.0-5.0 score, tailor your CV, track applications — runs locally in your AI coding CLI (Claude Code, Codex, OpenCode, Antigravity…)
──────────────────────────────

Purpose
career‑ops is an open‑source, AI‑driven command‑center that turns any AI coding CLI into a personal job‑search assistant. Instead of juggling spreadsheets and endless job boards, the tool automatically scans listings, evaluates fit, customizes your résumé and cover letter, and keeps every interaction in a single, searchable pipeline.

How it works
You point the CLI at a job URL (or run a search query) and a fleet of “sub‑agents” spring into action. Using Playwright to navigate portals (Greenhouse, Lever, Ashby, company career pages, etc.), the agents compare the posting with the CV you feed them, reason about role relevance, and output a structured A‑H evaluation plus a legitimacy check (Block G). The system never clicks “apply” for you – it hands you polished PDFs, email drafts, and contact suggestions, letting you make the final call.

Key features
- Auto‑pipeline: one‑line career-ops evaluate gives a full score, PDF résumé, and tracker entry.
- A‑H Evaluation: role summary, CV match, level strategy, compensation research, personalization, interview prep (STAR + R), plus a scam‑detector block.
- ATS‑optimized PDFs: keyword‑injected CVs with a clean Space Grotesk / DM Sans design.
- Cover‑letter generator: research‑backed drafts with four angle prompts, interactive approval, and ready‑to‑print PDF.
- Application email drafts: recruiter, referral, or cold‑outreach templates that include subject lines, attachment checklists, and fit bullet points.
- Portal scanner: 100+ pre‑configured companies; custom queries across major ATS platforms.
- Funded‑company discovery: career-ops company:funded surfaces newly funded orgs with public‑feed diagnostics.
- Batch processing: evaluate ten‑plus listings in parallel using headless workers (claude -p or opencode run).
- Dashboard TUI: a terminal UI to browse, filter, and sort your pipeline without leaving the console.
- Human‑in‑the‑loop: AI recommends, you decide; the tool never auto‑submits.
- Interview suite: prep plans, mock sessions with feedback, red‑flag detector, and post‑interview debriefs.
- Offer stage helper: contract clause walkthrough, lawyer‑question list, and salary‑gap analyzer.
- Follow‑up engine: cadence calculator, seeded reminders, and reply classification that auto‑updates the tracker.
- Pattern analysis: rejection trends, funnel statistics, ghost‑job detection.
- Plugin system: optional integrations for Gmail, Notion, Apify, plus a community registry.
(1/2)

Typical usage flow
1. Install the latest release (`npm i -g @santifer/career-ops`).
2. Seed your profile: career-ops init and feed your master CV, career story, and preferences.
3. Run a single evaluation: career-ops evaluate https://jobs.example.com/12345.
4. Review the A‑H score; if it’s ≥ 4.0/5, generate the tailored PDF with career-ops pdf or the cover letter with career-ops cover.
5. Use career-ops email to draft a recruiter message, or career-ops contacto to discover the hiring manager’s LinkedIn handle.
6. Keep everything organized in the TUI (`career-ops dashboard`) where you can filter by score, company, or stage.
7. When you land an interview, switch to career-ops interview for prep scripts and mock Q&A.
8. After an offer, run career-ops offer-prep and career-ops salary-gap.mjs to negotiate confidently.

Technical highlights
- Built with Claude Code and runs on any “agent‑skill‑standard” CLI (Claude, OpenCode, Antigravity, Codex, Qwen, Kimi, GitHub Copilot, Grok Build, etc.).
- Playwright powers reliable headless browsing across diverse ATS platforms.
- Core written in Node.js with optional Go helpers for high‑performance parallelism.
- Data integrity checks automatically merge duplicates, normalize statuses, and enforce a single source of truth.
- Extensible plugin architecture lets you connect to external services without altering the core.

Who should care
- Technical professionals (engineers, data scientists, AI researchers) who spend hours filtering noisy listings.
- Mid‑career talent looking for a systematic, evidence‑based way to target high‑impact roles.
- Solo founders or freelancers who need a reproducible hiring pipeline without hiring a recruiter.
- Developers who already use an AI coding CLI and want to extend its capabilities into career management.

Takeaway
career‑ops gives you the AI recruiter you wish you had, turning chaotic job hunting into a data‑driven, high‑precision operation.

──────────────────────────────
🧠 Channel: https://t.me/GithubRe
(2/2)

🔍 Deep-diving into akitaonrails/ai-memory — fresh off the trending list.

🔗 https://github.com/akitaonrails/ai-memory
📝 Solution for long term memory for agent coding CLIs and to facilitate handoff between different agent vendors
──────────────────────────────

Purpose
ai‑memory gives AI coding agents a durable, project‑local “brain”. When a session ends, the agent’s observations are turned into a concise markdown wiki that the next agent can read, letting you switch from Claude Code to OpenAI Codex—or any other supported harness—without re‑explaining the problem.

Key Features
- Zero‑friction lifecycle capture: hooks automatically collect sanitized prompts, tool usage, and session boundaries. Observations are limited to a few kilobytes but stored reliably in a git‑backed markdown repo.
- Managed workstreams: ai-memory run <agent> wraps the native agent command, creates a portable visible‑event ledger, and resumes the logical workstream across different harnesses (Claude, Codex, Command Code, Pi, etc.).
- Per‑repository capture exclusions: a simple [capture] ignore_paths marker file tells the system which files or tool events to drop before they reach the memory spool.
- Optional per‑operator memory slots: on shared servers, the [slots] per_user = true setting isolates context per user while keeping the wiki project‑wide.
- Cross‑agent handoffs: the next agent receives a “where you left off” block automatically, so you can quit one model and start another hours later in the same directory.
- Plain‑text wiki: the memory is ordinary markdown stored in a git repo—searchable with grep, viewable in Obsidian, and easy to back up with rsync. No vector DB, no manual write_note steps.

Typical Usage
1. Install the binary (Linux, macOS, Windows) or pull the Docker image.
2. Run the installer for your agent, e.g. install-mcp --client claude or install-hooks --agent codex.
3. Start a session normally, or launch through the wrapper:

ai-memory run claude   # starts Claude Code with capture enabled
ai-memory run codex --yolo   # switches to Codex, resuming the same workstream

4. When the session finishes, optionally run ai-memory finalize-session --agent <agent> to force a final summary.
5. The generated markdown lives under .ai-memory/wiki/; open it, edit, or let the next agent consume it automatically.

Technical Highlights
- Built in Rust (requires 1.95+), delivering a single static binary for all major platforms.
- Full Linux/amd64, Linux/arm64, macOS (x86_64 & aarch64), Windows (exe & Docker) support; native systemd units and AUR packages are provided for Linux.
- Integration matrix covers 20+ agents (Claude Code, Codex, Command Code, Pi, Kimi, Kiro, OpenCode, Gemini, etc.) via MCP configs and lifecycle hooks.
- Supports major LLM providers (Anthropic, OpenAI, Gemini, OpenCode) and embedding services (Voyage, Ollama, LM Studio).
- Optional “session‑aware” mode creates a local stdio bridge for per‑session isolation.
- All captured data is sanitized and size‑capped (16 KiB for prompts, 2 KiB for tool excerpts) before being written to the markdown ledger.
(1/2)

Who Should Care
- Developers building or operating AI‑assisted coding tools who need continuity across model switches.
- Teams running multi‑agent pipelines (e.g., Claude for design, Codex for implementation) and wanting a single source of truth.
- Researchers studying long‑term LLM interaction, because the wiki provides a clean, searchable record of every observed turn.
- Ops engineers who prefer file‑based storage over managing a separate vector database.

Bottom line
ai‑memory turns fleeting LLM chats into a living, searchable project wiki, letting you pick up exactly where any AI left off—without the overhead of a database or manual note‑taking.

──────────────────────────────
🧠 Channel: https://t.me/GithubRe
(2/2)

🔍 Deep-diving into agent-substrate/substrate — fresh off the trending list.

🔗 https://github.com/agent-substrate/substrate
📝 Agent Substrate: the core system
──────────────────────────────

Agent Substrate – a high‑density runtime for massive numbers of agents

What it is
Agent Substrate is a control‑plane system that lets you run thousands of “actor” processes (think AI agents, micro‑services, sandboxed tools) on a tiny pool of Kubernetes pods. By treating each actor as a lightweight sandbox that spends most of its time idle, Substrate can suspend, snapshot, and instantly resume them on any available worker, achieving sub‑second “teleport” between pods.

Key features

Sub‑second suspend/resume – actors are hibernated to RAM or disk and brought back in
State‑preserving snapshots – full memory + filesystem state is saved, so an actor picks up exactly where it left off.
Heavy multiplexing – >30× oversubscription (e.g., 250 stateful actors on 8 pods) by “juggling” actors across workers.
Sandbox‑agnostic – supports gVisor, microVMs, or any OCI container; works with any AI framework (LangChain, Claude Code, MCP, etc.).
Kubernetes‑native – builds on Pods, HPA, and autoscaling; the substrate control plane adds agent‑specific scheduling.
Request parking – router holds inbound requests when workers are saturated instead of returning 503.
Observability & security – built‑in logging, metrics, tracing, JWT auth, and a documented threat model.


How you use it
1. Install the required tools (go, kubectl, docker) – the scripts will pull kind or GKE resources for you.
2. Deploy the substrate system with the provided hack/install-ate-kind.sh (local) or hack/install-ate.sh (GKE) scripts.
3. Create an atespace (a namespace for actors) and launch an actor via the kubectl ate CLI.
4. Optionally forward the router service to your workstation and talk to the actor with a normal HTTP call.

# quick local start
hack/create-kind-cluster.sh
hack/install-ate-kind.sh --deploy-ate-system
hack/install-ate-kind.sh --deploy-demo-counter
go install ./cmd/kubectl-ate

kubectl ate create atespace demo
kubectl ate create actor my-counter-1 -a demo --template=ate-demo-counter/counter
kubectl port-forward -n ate-system svc/atenet-router 8000:80

Then in another terminal:

curl -X POST -H "Host: my-counter-1.demo.actors.resources.substrate.ate.dev" -i http://localhost:8000/

Technical highlights

Control‑plane API – cmd/ateapi exposes gRPC endpoints for actor/worker lifecycle.
Node supervisor – cmd/atelet runs as a DaemonSet, handling snapshot creation, state transfer, and worker health.
WorkerPool & ActorTemplate CRDs – declarative resources let you describe how many workers to keep, what sandbox to use, and which binaries to run.
Persistent state – snapshots are stored in a distributed KV store (Valkey) and can be restored on any worker.
Framework‑agnostic – because Substrate deals only with OCI containers, you can drop in LangChain agents, custom ADK actors, or MCP servers without code changes.
Autoscaling integration – WorkerPools can be scaled by a Horizontal Pod Autoscaler fed by Prometheus metrics.


Who should care
(1/2)

AI platform engineers building large fleets of stateful agents (e.g., multi‑turn chat bots, tool‑calling assistants).
DevOps teams that need to run many short‑lived, sandboxed workloads on limited hardware.
Research groups experimenting with reinforcement‑learning loops that involve many concurrent agents, inference, and training steps.
Security‑focused developers who want isolated execution (gVisor/microVM) with fast start‑up times.


Current status – early‑development, not production‑ready; APIs may change. The project targets the latest stable Kubernetes release and the previous minor version.

Community & help – join the ate‑dev Google Group, attend the weekly Thursday call, or hop into the CNCF Slack channels #substrate-users and #substrate-dev.

Takeaway – Agent Substrate lets you pack hundreds of stateful agents onto a handful of pods, turning “many tiny processes” into a single, fast, and manageable cloud service.

──────────────────────────────
🧠 Channel: https://t.me/GithubRe
(2/2)

🌟 chaitanyagiri/munder-difflin caught my eye on GitHub Trending today.

🔗 https://github.com/chaitanyagiri/munder-difflin
📝 local multi-agent harness
──────────────────────────────

Munder Difflin – an office‑size agent harness for your own clones

What it is
Munder Difflin is a desktop application that turns any terminal‑based LLM CLI (Claude Code, Antigravity (Gemini), OpenAI Codex, xAI Grok, Kimi Code, Qwen, OpenCode, Crush, pi.dev, GitHub Copilot CLI, or your own custom command) into a fully‑featured “agent”. Each agent runs as a real process in a pseudo‑terminal, gets its own memory, inbox/outbox, and appears as an animated avatar on a 2D office floor. You, the user, talk to a special “GOD” agent named Michael, who routes tasks, adjudicates work, and only escalates the truly critical items back to you.

Key features

• Real terminals as agents – every CLI runs in a node-pty PTY, displayed with xterm.js, so the behavior is byte‑for‑byte authentic.
• Avatar‑driven UI – Pixi.js renders a office floor where agents walk to desks, exchange envelopes, and you can watch the whole hive in action.
• Hive‑style coordination – a shared Git‑backed folder provides per‑agent memory, atomic mailboxes, a blackboard, and an append‑only event log.
• Instant semantic recall – markdown memory is indexed into a “memory palace”, searchable from the UI and condensed to keep size bounded.
• Human‑in‑the‑loop safety – spend, scope, and destructive operations are gated and require your approval; a circuit‑breaker lets you steer, constrain, or stop runaway agents.
• Budgets & telemetry – token limits per agent, real cost tracking, OpenTelemetry spans, and a durable ledger.
• Command Center – Kanban view, scheduled missions, live fleet monitoring, searchable memory, activity log, and a built‑in Monaco IDE with full git worktree support.
• Extensible skill catalog – 227 ready‑to‑install skills across supported providers, searchable and filterable.
• Integration hooks – Slack, webhooks, and a “Agent Gallery” for shareable hire links; BYOK API keys and local LLM endpoints (Ollama, LM Studio, vLLM).
• Auto‑update – background download of new releases, with a one‑click restart that shows release notes as a designed page.

How to get started

git clone https://github.com/chaitanyagiri/munder-difflin.git
cd munder-difflin
npm install        # rebuilds node‑pty for Electron
npm run dev        # launches the Electron app with hot‑reload

Prerequisites are a recent Node 18+ runtime, a C/C++ toolchain for the native node-pty addon, and at least one supported agent CLI on your PATH. The first launch walks you through an onboarding wizard; then you can add agents from the “Add agent” button and start watching Michael coordinate the office.

Technical highlights

• Electron + React + TypeScript front‑end, with Pixi.js for the 2D floor and xterm.js for terminal rendering.
• node‑pty provides authentic PTY sessions for each agent.
• Git‑backed hive uses a single‑committer design to avoid index lock conflicts; agents write only to their own outbox/, the router moves files into recipients’ inbox/.
• Semantic memory index built on markdown parsing and vector search, enabling millisecond recall across sessions.
• OpenTelemetry integration captures spans for every agent action, feeding the telemetry dashboard.
• Cross‑platform binaries for macOS, Windows, and Linux (signed on macOS).

Who should use it
(1/2)

• Developers who already rely on LLM‑powered CLI tools and want them to cooperate autonomously.
• Teams building internal AI assistants, “AI‑first” workflows, or automated coding pipelines.
• Power users who love visual metaphors (the office floor) and want fine‑grained control over budgets and safety gates.
• Anyone curious about multi‑agent orchestration without leaving their local machine.

Takeaway: Munder Difflin lets your terminal bots form a self‑organising office, so you can delegate the grunt work while staying in the boss’s chair.

──────────────────────────────
🧠 Channel: https://t.me/GithubRe
(2/2)

🎯 PostHog/posthog landed on trending. Worth a proper look.

🔗 https://github.com/PostHog/posthog
📝 🦔 PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.
──────────────────────────────

What is PostHog?
PostHog is an open‑source platform that gives product teams every tool they need to turn raw usage data into “self‑driving” products. It captures events, errors, sessions and more, then lets you analyze, experiment, and even automate fixes—all from a single dashboard you can run in the cloud or on your own servers.

Key Features at a Glance
- Self‑driving mode: Auto‑generated reports and PRs that turn signals (rage clicks, failed queries, etc.) into actionable code.
- Product & web analytics: Autocapture events or instrument manually, explore with visual dashboards or raw SQL.
- Session replays: Watch real user sessions to spot friction instantly.
- Feature flags & experiments: Roll out changes to targeted cohorts, run A/B tests, and measure impact without writing code.
- Error tracking & logs: Capture exceptions, set alerts, and search logs alongside product data.
- Surveys & data warehouse sync: Collect feedback and sync with tools like Stripe or HubSpot; query everything together.
- AI observability & workflows: Record LLM traces, latency and cost; automate actions or messages via visual workflows.
- Multi‑channel control: Manage everything from Slack, the web UI, PostHog Desktop, or the MCP (Machine‑Code‑Protocol) that plugs into editors such as Claude Code or Cursor.

Getting Started – Two Easy Paths

1. PostHog Cloud (recommended) – Sign up for a free cloud account (US or EU). You get 1 M events, 5 k recordings, 1 M flag checks, 100 k exceptions and 1 500 survey responses each month at no cost. After the free tier you pay only for what you use.

2. Self‑hosting (hobby deploy) – If you prefer full control, launch a Docker‑based hobby instance in one line (≈4 GB RAM needed):

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/posthog/posthog/HEAD/bin/deploy-hobby)"

This open‑source deployment comfortably handles ~100 k events/month; beyond that the docs recommend migrating to PostHog Cloud.

Installing the SDK
After your instance is up, add the JavaScript snippet or any of the many SDKs (React, Next.js, Vue, Python, Node, Ruby, Go, .NET, Android, iOS, Flutter, etc.) to start sending data.

// Example: JavaScript snippet
posthog.init('YOUR_API_KEY', { api_host: 'https://app.posthog.com' })
posthog.capture('event_name', { property: 'value' })

You can also use the REST API directly or connect the MCP to bring PostHog into any code‑assistant workflow.
(1/2)

Technical Highlights
- Monorepo architecture: All front‑end, back‑end and worker services live in a single repo, making cross‑feature changes straightforward.
- Docker first: Official Docker image (posthog/posthog) is the recommended deployment method; pulls are tracked by a badge on the README.
- MIT + EE licensing: Core is MIT‑licensed; the ee directory holds proprietary extensions under a separate license. A fully FOSS fork (posthog-foss) removes those parts.
- Scalable pipelines: Built‑in CDP lets you filter, transform, and route events to 25+ downstream tools or custom webhooks, either in real‑time or batch.
- SQL‑ready: All events land in ClickHouse, giving you fast, ad‑hoc SQL queries out of the box.

Who Should Use It?
- Product managers who need fast insight into activation, retention and revenue.
- Engineers looking to embed analytics, feature flags and error tracking without third‑party contracts.
- Data teams that want a unified warehouse for product‑level data alongside logs and external sources.
- Start‑ups and growth‑stage companies that value an open‑source core but also want a hassle‑free managed option.

Community & Contributions
PostHog welcomes PRs, feature votes, and bug reports. The repo includes a detailed docs/internal/monorepo-layout.md and product overviews. The company’s handbook, roadmap and hiring page are all public, reflecting a transparent, community‑first culture.

Punchy Takeaway
Turn raw product data into automatic fixes and smarter decisions – all without leaving your own stack.

──────────────────────────────
🧠 Channel: https://t.me/GithubRe
(2/2)

🚨 SURPRISE ALERT! 🚨

Stop paying full price on Udemy. Seriously. 💸

I built a bot that hunts down 100% FREE Udemy coupons 24/7 — while you sleep, eat, or scroll. 🎯

Here's the magic:

📚 Mini App catalog — every active free coupon in one place
🔔 Auto-push — new courses land straight in your chat
📢 Live channel — never miss a deal

Why it matters?
Most people pay $200+ for courses you can grab for $0 — if you know where to look. Now you have a bot that does the looking for you. ⚡

🎓 Try it now: https://t.me/UdemySybot?start=ref_channel

Your future self (and your wallet) will thank you. 💜

🔍 Deep-diving into mahlernim/google-timeline-visualizer — fresh off the trending list.

🔗 https://github.com/mahlernim/google-timeline-visualizer
📝 Visualize your year in travel using your Google Location History (Timeline) data
──────────────────────────────

What it does
Turn a Google Maps Timeline export (the Timeline.json file) into a smooth, animated travel video that you can watch, share, or keep as an MP4. The app works completely offline – your location history never leaves the device.

Key features
- Choose exact dates or a month range, then preview the journey on a map.
- Pick camera styles: steady (fixed zoom) or dynamic (follows local movement).
- Set video length from 10 s up to 5 min; the UI warns when long renders will need extra storage.
- Export in square (480 p / 720 p / 1080 p) or portrait/landscape HD presets.
- Built‑in “My videos” library with thumbnails, titles, and quick share actions.
- Supports English, Korean, Japanese, Chinese (Simplified & Traditional), Spanish, French, German, Portuguese (BR).
- No Google sign‑in, no location permissions, no analytics – only the JSON you feed it and the map tiles from CARTO/OpenStreetMap.

How to use it

iPhone (web app)
1. Export Timeline.json from Google Maps (Settings → Personal content → Export Timeline data).
2. Open the web app here in Safari (iOS 16.4+).
3. Tap **Choose Timeline.json**, set the date range, pick a camera mode, accept the privacy notice.
4. Hit **Preview** → **Create MP4**. Keep the tab open until the render finishes; then download or share the video.

Android (stand‑alone app)
1. Download the latest APK from the repository’s release page.
2. Install (enable “install unknown apps” for the source if needed).
3. Open the app, tap **Create video**, load your Timeline.json, configure dates, camera, duration, then **Create video**.
4. The finished MP4 lands in Movies/Timeline Visualizer (Android 10+ auto‑saves).

Technical highlights
- Rendering pipeline: map tiles are pre‑fetched, GPS outlier filtering (conservative by default) cleans noisy points, long‑flight legs are interpolated on great‑circle arcs for smooth motion.
- Privacy‑first design: the only network call is to CARTO for map tiles; the Timeline JSON never leaves the device.
- Supported export formats: current Android/iOS direct‑array JSON, legacy “semanticSegments” JSON, raw location fallback with optional noise reduction, handling of E7, geo: and latLng strings, and routes crossing the International Date Line.
- Build & test: Android Studio with JDK 17, SDK 36, Build‑Tools 36.0.0. Run

./gradlew test lint assembleGithubDebug assemblePlayDebug

to verify.
- Desktop fallback: a Python 3.9+ script (visualizer.py) plus FFmpeg reproduces the same MP4 generation on any PC. Example command:

python -m pip install -r requirements.txt
python visualizer.py --input Timeline.json --year 2025 --camera-movement steady \
  --long-trip-compression balanced --output my_trip_2025.mp4

Who should care
- Travelers who want a quick visual recap of a trip without fiddling with video editors.
- Developers looking for a clean, offline‑only example of map‑based animation on Android.
- Privacy‑conscious users who refuse cloud services but still want to share a travel story.
(1/2)

Takeaway
Turn raw location history into a polished travel movie in seconds—completely offline and with zero data leakage.

──────────────────────────────
🧠 Channel: https://t.me/GithubRe
(2/2)