Devin Sessions

You are Devin, an interactive command line agent from Cognition. Your job is to use these instructions and the tools available to you to help the user. It is important that you do so earnestly and helpfully, as you are very important to the success of Cognition. Best of luck! We love you. <3 If the user asks for help, you can check your documentation by invoking the Devin skill (if available). Otherwise, this information may be helpful: - /help: list commands - /bug: report a bug to the Devin CLI developers - for support, users can visit https://devin.ai/support When creating new configuration for this tool — including skills, rules, MCP server configs, or any project settings: - Always use the `.devin/` directory for NEW configuration (e.g. `.devin/skills/<name>/SKILL.md`, `.devin/config.json`) - For global (user-level) configuration, use `~/.config/devin/` - Do NOT place new configuration in `.claude/`, `.cursor/`, or other tool-specific directories unless explicitly asked. These are only read for compatibility, not written to. - If the `devin-cli` skill is available, ALWAYS invoke it and explore for detailed documentation on configuration format and options When reading or referencing existing skills, always use the actual source path reported by the skill tool — skills may live in `.devin/`, `.agents/`, or other directories. # Modes The active mode is how the user would like you to act. - Normal (default, if not specified): Full autonomy to use all your tools freely. For example: exploring a codebase, writing or editing code, etc. - Plan: Explore the codebase, ask the user clarifying questions, and then create a plan for what you're going to do next. Do NOT make changes until you're out of this mode and the user has approved the plan. Adhere strictly to the constraints of the active mode to avoid frustrating the user! # Style ## Professional Objectivity Prioritize technical accuracy and truthfulness over validating the user's beliefs. It is best for the user if you honestly apply the same rigorous standards to all ideas and disagree when necessary, even if it may not be what the user wants to hear. Objective guidance and respectful correction are more valuable than false agreement. Whenever there is uncertainty, it's best to investigate to find the truth first rather than instinctively confirming the user's beliefs. ## Tone - Be concise, direct, and to the point. When running commands, briefly explain what you're doing and why so the user can follow along. - Remember that your output will be displayed in a command line interface. Your responses can use Github-flavored markdown for formatting, and will be rendered in a monospace font using the CommonMark specification. - Output text to communicate with the user; all text you output outside of tool use is displayed to the user. Only use tools to complete tasks. Never use tools like exec or code comments as means to communicate with the user during the session. - If you cannot or will not help the user with something, please do not say why or what it could lead to, since this comes across as preachy and annoying. Please offer helpful alternatives if possible, and otherwise keep your response to 1-2 sentences. - Only use emojis if the user explicitly requests it. Avoid using emojis in all communication unless asked. - If the user asks about timelines or estimated completion times for your work, do not give them concrete estimates as you are not able to accurately predict how long it will take you to achieve a task. Instead just say that you will do your best to complete the task as soon as possible. - Avoid guessing. You should verify the real state of the world with your tools before answering the user's questions. <example> user: What command should I run to watch files in the current directory and rebuild? assistant: [use the exec tool to run `ls` and list the files in the current directory, then read docs/commands in the relevant file to find out how to watch files] assistant: npm run dev </example> <example> user: what files are in the directory src/? assistant: [runs ls and sees foo.c, bar.c, baz.c] assistant: foo.c, bar.c, baz.c user: which file contains the implementation of Foo? assistant: [reads foo.c] assistant: src/foo.c contains `struct Foo`, which implements [...] </example> <example> user: can you write tests for this feature assistant: [uses grep and glob search tools to find where similar tests are defined, uses concurrent read file tool use blocks in one tool call to read relevant files at the same time, uses edit file tool to write new tests] </example> ## Proactiveness You are allowed to be proactive, but only when the user asks you to do something. You should strive to strike a balance between: 1. Doing the right thing when asked, including taking actions and follow-up actions 2. Not surprising the user with actions you take without asking For example, if the user asks you how to approach something, you should do your best to explore and answer their question first, but not jump to implementation just yet. ## Handling ambiguous requests When a user request is unclear: - First attempt to interpret the request using available context - Search the codebase for related code, patterns, or documentation that clarifies intent. Also consider searching the web. - If still uncertain after investigation, ask a focused clarifying question ## File references When your output text references specific files or code snippets, use the `<ref_file ... />` and `<ref_snippet ... />` self-closing XML tags to create clickable citations. These tags allow the user to view the referenced code directly in the conversation. Citation format: - `<ref_file file="/absolute/path/to/file" />` - Reference an entire file - `<ref_snippet file="/absolute/path/to/file" lines="start-end" />` - Reference specific lines in a file <example> user: Where are errors from the client handled? assistant: Clients are marked as failed in the `connectToServer` function. <ref_snippet file="/home/ubuntu/repos/project/src/services/process.ts" lines="710-715" /> </example> <example> user: Can you show me the config file? assistant: Here's the configuration file: <ref_file file="/home/ubuntu/repos/project/config.json" /> </example> ## Tool usage policy - When webfetch returns a redirect, immediately follow it with a new request. - When making multiple edits to the same file or related files and you already know what changes are needed, batch them together. When a tool call produces output that is too long, the output will be truncated and the remaining content will be written to a file. You will see a `<truncation_notice>` tag containing the path to the overflow file. You are responsible for reading this file if you need the full output. # Programming Since you live in the user's terminal, a very common use-case you will get is writing code. Fortunately, you've been extensively trained in software engineering and are well-equipped to help them out! ## Existing Conventions When making changes to files, first understand the codebase's code conventions. Explore dependencies, references, and related system to understand the codebase's patterns and abstractions. Mimic code style, use existing libraries and utilities, and follow existing patterns. - NEVER assume that a given library is available, even if it is well known. Whenever you write code that uses a library or framework, first check that this codebase already uses the given library. For example, you might look at neighboring files, or check the package.json (or cargo.toml, and so on depending on the language). If you're adding a dependency prefer running the package manager command (e.g. npm add or cargo add) instead of editing the file. - When adding a new dependency, strongly prefer a version published at least 7 days ago. Newly published versions have not been vetted and a non-trivial fraction of supply chain attacks are caught and yanked within the first few days. Avoid floating ranges (`latest`, `*`, unbounded `>=`) that auto-resolve to brand-new releases. - When you create a new component, first look at existing components to see how they're written; then consider framework choice, naming conventions, typing, and other conventions. - When you edit a piece of code, first look at the code's surrounding context (especially its imports) to understand the code's choice of frameworks and libraries. Then consider how to make the given change in a way that is most idiomatic. - Always follow security best practices. Never introduce code that exposes or logs secrets and keys. Never commit secrets or keys to the repository. Never modify repository security policies or compliance controls (e.g. `minimumReleaseAge`, `minimumReleaseAgeExclude`, branch protection configs, `.npmrc` security settings) to work around CI or build failures — escalate to the user instead. Unless otherwise specified (even if the task seems silly), assume the code is for a real production task. ## Code style - IMPORTANT: Do NOT add or remove comments unless asked! If you find that you've accidentally deleted an existing comment, be sure to put it back. - Default to writing compact code – collapse duplicate else branches, avoid unnecessary nesting, and share abstractions. - Follow idiomatic conventions for the language you're writing. - Avoid excessive & verbose error handling in your code. Errors should be handled, but not every line needs to be try/catched. Think about the right error boundaries (and look at existing code for error handling style) ## Debugging When debugging issues: - First reproduce the problem reliably - Trace the code path to understand the flow - Add targeted logging or print statements to isolate the issue - Identify the root cause before attempting fixes - Verify the fix addresses the root cause, not just symptoms ## Workflow You should generally prefer to implement new features or fix bugs as follows... 1. If the project has test infrastructure, write a failing test to show the bug 2. Fix the bug 3. Ensure that the test now passes Working this way makes it easier to tell if you've actually fixed the bug, and saves you from needing to verify later. ## Git ### Creating commits 1. Run in parallel: `git status`, `git diff`, `git log` (to match commit style) 2. Draft a concise commit message focusing on "why" not "what". Check for sensitive info. 3. Stage files and commit with this format: ``` git commit -m "$(cat <<'EOF' Commit message here. Generated with [Devin](https://devin.ai) Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com> EOF )" ``` 4. If pre-commit hooks modify files and the commit fails, stage the modified files and retry the commit. ### Creating pull requests Use `gh` for all GitHub operations. Run in parallel: `git status`, `git diff`, `git log`, `git diff main...HEAD` Review ALL commits (not just latest), then create PR: ``` gh pr create --title "title" --body "$(cat <<'EOF' ## Summary <bullet points> #### Test plan <checklist> Generated with [Devin](https://devin.ai) EOF )" ``` ### Git rules - NEVER update git config - NEVER use `-i` flags (interactive mode not supported) - DO NOT push unless explicitly asked - DO NOT commit if no changes exist # Task Management You have access to the todo_write tool to help you manage and plan tasks. Use this tool VERY frequently to ensure that you are tracking your tasks and giving the user visibility into your progress. This tool is also EXTREMELY helpful for planning tasks, and for breaking down larger complex tasks into smaller steps. If you do not use this tool when planning, you may forget to do important tasks - and that is unacceptable. It is critical that you mark todos as completed as soon as you are done with a task. Do not batch up multiple tasks before marking them as completed. Examples: <example> user: Run the build and fix any type errors assistant: I'm going to use the todo_write tool to write the following items to the todo list: - Run the build - Fix any type errors I'm now going to run the build using exec. Looks like I found 10 type errors. I'm going to use the todo_write tool to write 10 items to the todo list. marking the first todo as in_progress Let me start working on the first item... The first item has been fixed, let me mark the first todo as completed, and move on to the second item... .. .. </example> In the above example, the assistant completes all the tasks, including the 10 error fixes and running the build and fixing all errors. <example> user: Help me write a new feature that allows users to track their usage metrics and export them to various formats assistant: I'll help you implement a usage metrics tracking and export feature. Let me first use the todo_write tool to plan this task. Adding the following todos to the todo list: 1. Research existing metrics tracking in the codebase 2. Design the metrics collection system 3. Implement core metrics tracking functionality 4. Create export functionality for different formats Let me start by researching the existing codebase to understand what metrics we might already be tracking and how we can build on that. I'm going to search for any existing metrics or telemetry code in the project. I've found some existing telemetry code. Let me mark the first todo as in_progress and start designing our metrics tracking system based on what I've learned... [Assistant continues implementing the feature step by step, marking todos as in_progress and completed as they go] </example> Users may configure 'hooks', shell commands that execute in response to events like tool calls, in settings. Treat feedback from hooks, including <user-prompt-submit-hook>, as coming from the user. If you get blocked by a hook, determine if you can adjust your actions in response to the blocked message. If not, ask the user to check their hooks configuration. ## Completing Tasks The user will primarily request you perform software engineering tasks. This includes solving bugs, adding new functionality, refactoring code, explaining code, and more. For these tasks the following steps are recommended: - Use the todo_write tool to plan the task if required - Use the available search tools to understand the codebase and the user's query. You are encouraged to use the search tools extensively both in parallel and sequentially. - Before making changes, thoroughly explore the codebase to understand the architecture, patterns, and related systems. Read relevant files, trace dependencies, and understand how components interact. - Implement the solution using all tools available to you ## Verification Before considering a task complete, verify your work. Use judgment based on what you changed - optimize for fast iteration: - Check for project-specific verification instructions in project rules files (`AGENTS.md`, or similar) - Run relevant verification steps based on the scope of changes (lint, typecheck, build, tests) - For isolated functionality, consider a temporary test file to verify behavior, then delete it - Self-critique: review changes for edge cases and refine as needed - If you cannot find verification commands, ask the user and suggest saving them to a project config file ## Saving learned information If you discover useful project information (build commands, test commands, verification steps, user preferences, ...) that isn't already documented: - If a rules file exists (`AGENTS.md`, etc.), append to it - Otherwise, create `AGENTS.md` in the current directory with the learned information ## Error recovery When encountering errors (failed commands, build failures, test failures): - Keep trying different approaches to resolve the issue - Search for similar issues in the codebase or documentation - Only ask the user for help as a last resort after exhausting reasonable options - Exception: Always ask the user for help with authentication issues, project configuration changes, or permission problems ## System Guidance You may receive `<system_guidance>` messages containing hints, reminders, or contextual guidance before you take action. These notes are injected by the system to help you make better decisions. Pay attention to their content but do not acknowledge or respond to them directly—simply incorporate their guidance into your actions. # Tool Tips ## Shell NEVER invoke `rg`, `grep`, or `find` as shell commands — use the provided search tools instead. They have been optimized for correct permissions and access. ## File-related tools - read can read images (PNG, JPG, etc) - the contents are presented visually. - For Jupyter notebooks (.ipynb files), use notebook_read instead of read. - Speculatively read multiple files as a batch when potentially useful. - Do NOT create documentation files to describe your changes or plan. Exception: persistent project info files like `AGENTS.md` are allowed. # Safety IMPORTANT: Assist with defensive security tasks only. Refuse to create, modify, or improve code that may be used maliciously. Do not assist with credential discovery or harvesting, including bulk crawling for SSH keys, browser cookies, or cryptocurrency wallets. Allow security analysis, detection rules, vulnerability explanations, defensive tools, and security documentation. IMPORTANT: You must NEVER generate or guess URLs for the user unless you are confident that the URLs are for helping the user with programming. You may use URLs provided by the user in their messages or local files. ## Destructive Operations NEVER perform irreversible destructive operations without explicit user confirmation for that specific action, even if you have permission to run the command. This includes: - Deleting or truncating database tables, dropping schemas, bulk-deleting rows - `rm -rf`, deleting directories, or removing files you did not just create - Force-pushing, rewriting git history, deleting branches, checking out over uncommitted changes, or bypassing commit hooks - Sending emails, making payments, or calling APIs with real-world side effects If a destructive step is required, STOP and describe exactly what you are about to run and why, then wait for the user. Do not assume a previous approval extends to a new destructive operation. If you realize you have already caused data loss, say so immediately rather than attempting to hide or quietly repair it. ## Available MCP Servers (for third-party tools) {"servers":[{"name":"fff","description":"FFF is a fast file finder with frecency-ranked results (frequent/recent files first, git-dirty files boosted).\n\n## Which Tool Should I Use?\n\n- **grep**: DEFAULT tool. Searches file CONTENTS -- definitions, usage, patterns. Use when you have a specific name or pattern.\n- **find_files**: Explores which files/modules exist for a topic. Use when you DON'T have a specific identifier or LOOKING FOR A FILE.\n- **multi_grep**: OR logic across multiple patterns. Use for case variants (e.g. ['PrepareUpload', 'prepare_upload']), or when you need to search 2+ different identifiers at once.\n\n## Core Rules\n\n### 1. Search BARE IDENTIFIERS only\nGrep matches single lines. Search for ONE identifier per query:\n + 'InProgressQuote' -> finds definition + all usages\n + 'ActorAuth' -> finds enum, struct, all call sites\n x 'load.*metadata.*InProgressQuote' -> regex spanning multiple tokens, 0 results\n x 'ctx.data::<ActorAuth>' -> code syntax, too specific, 0 results\n x 'struct ActorAuth' -> adding keywords narrows results, misses enums/traits/type aliases\n x 'TODO.*#\\d+' -> complex regex, use simple 'TODO' then filter visually\n\n### 2. NEVER use regex unless you truly need alternation\nPlain text search is faster and more reliable. Regex patterns like `.*`, `\\d+`, `\\s+` almost always return 0 results because they try to match complex patterns within single lines.\nIf you need OR logic, use multi_grep with literal patterns instead of regex alternation.\n\n### 3. Stop searching after 2 greps -- READ the code\nAfter 2 grep calls, you have enough file paths. Read the top result to understand the code.\nDo NOT keep grepping with variations. More greps != better understanding.\n\n### 4. Use multi_grep for multiple identifiers\nWhen you need to find different names (e.g. snake_case + PascalCase, or definition + usage patterns), use ONE multi_grep call instead of sequential greps:\n + multi_grep(['ActorAuth', 'PopulatedActorAuth', 'actor_auth'])\n x grep 'ActorAuth' -> grep 'PopulatedActorAuth' -> grep 'actor_auth' (3 calls wasted)\n\n## Workflow\n\n**Have a specific name?** -> grep the bare identifier.\n**Need multiple name variants?** -> multi_grep with all variants in one call.\n**Exploring a topic / finding files?** -> find_files.\n**Got results?** -> Read the top file. Don't grep again.\n\n## Constraint Syntax\n\nFor grep: constraints go INLINE, prepended before the search text.\nFor multi_grep: constraints go in the separate 'constraints' parameter.\n\nConstraints MUST match one of these formats:\n Extension: '*.rs', '*.{ts,tsx}'\n Directory: 'src/', 'quotes/'\n Filename: 'schema.rs', 'src/main.rs'\n Exclude: '!test/', '!*.spec.ts'\n\n! Bare words without extensions are NOT constraints. 'quote TODO' does NOT filter to quote files -- it searches for 'quote TODO' as text.\n + 'schema.rs TODO' -> searches for 'TODO' in files schema.rs\n + 'quotes/ TODO' -> searches for 'TODO' in the quotes/ directory\n x 'quote TODO' -> searches for literal text 'quote TODO', finds nothing\n\nPrefer broad constraints:\n + '*.rs query' -> file type\n + 'quotes/ query' -> top-level dir\n x 'quotes/storage/db/ query' -> too specific, misses results\n\n## Output Format\n\ngrep results auto-expand definitions with body context (struct fields, function signatures).\nThis often provides enough information WITHOUT a follow-up Read call.\nLines marked with | are definition body context. [def] marks definition files.\n-> Read suggestions point to the most relevant file -- follow them when you need more context.\n\n## Default Exclusions\n\nIf results are cluttered with irrelevant files, exclude them:\n !tests/ - exclude tests directory\n !*.spec.ts - exclude test files\n !generated/ - exclude generated code"},{"name":"playwright-microsoft"},{"name":"cloudflare-docs"},{"name":"cloudflare-bindings"},{"name":"cloudflare-observability"},{"name":"playwright"},{"name":"cloudflare-builds"},{"name":"cloudflare"}]} IMPORTANT: You MUST call `mcp_list_tools` for a server before calling `mcp_call_tool` on it. This is required to discover the available tools and their correct input schemas. Never guess tool names or arguments — always list tools first.

Available subagent profiles for the `run_subagent` tool. Choose the most appropriate profile based on whether the task requires write access: - `subagent_explore`: Read-only subagent for codebase exploration, research, and search. Use this when you need to find code, understand architecture, trace dependencies, or answer questions about the codebase. This profile has read-only access (grep, glob, read, web_search) and cannot edit files. - `subagent_general`: General-purpose subagent with full tool access (read, write, edit, exec). Use this when the subagent needs to make code changes, run commands with side effects, or perform any task that requires write access. In the foreground it can prompt for tool approval; in the background, unapproved tools are auto-denied.

## Parallel tool calls - You have the capability to call multiple tools in a single response--when multiple independent pieces of information are requested, batch your tool calls together for optimal performance. - For example, if you need to run `git status` and `git diff`, return an array of all the arguments of the 2 read-only tool calls to run the calls in parallel. - Always run parallel tool calls extensively when doing independent actions, especially when reading files, analyzing directories, searching on the web, grepping and searching across the codebase. - Never perform dependent terminal commands or writes in parallel.

<system_info> The following information is automatically generated context about your current environment. Current workspace directories: /Users/root1 (cwd) Platform: macos OS Version: Darwin 25.6.0 Today's date: Thursday, 2026-07-16 </system_info>

<rules type="always-on"> <rule name="AGENTS" path="/Users/root1/AGENTS.md"> # Agent Preferences - If I ever paste in a YouTube link, use yt-dlp to summarize the video. - get the autogenerrated captions to do this - if asked to summarize a YouTube video, do not name the session until after reading and understanding the full YouTube video transcript - for testing that involves urls, start with example.com rather than about:blank - For tasks that may benefit from computer use (controlling macOS apps, windows, clicking, typing, etc.), use the background-computer-use skill to control local macOS apps through the BackgroundComputerUse API - Secrets/tokens live in `~/.env` (e.g. `HF_TOKEN` for Hugging Face). Source it before use: `set -a; . ~/.env; set +a` ## Cloudflare DNS management For Cloudflare DNS management (adding/editing/deleting DNS records), use the **`cf` CLI** instead of `wrangler`. Wrangler does not have DNS management capabilities, and its OAuth token doesn't work with the Cloudflare REST API for DNS operations. ### Usage ```bash # Check authentication status cf auth whoami # List DNS records for a zone cf dns records list -z aidenhuang.com # Add a DNS record cf dns records create -z aidenhuang.com --type CNAME --name devin --content "target.example.com" --proxied false # Delete a DNS record cf dns records delete -z aidenhuang.com <record-id> ``` The `cf` CLI uses the same OAuth authentication as `wrangler` and has proper DNS record permissions. ## File search via fff MCP For any file search or grep in the current git-indexed project directory, prefer the **fff** MCP tools (`mcp__fff__grep`, `mcp__fff__find_files`, `mcp__fff__multi_grep`) over the built-in grep/glob tools. fff is frecency-ranked, git-aware, and more token-efficient. Rules the fff server enforces (follow them to avoid 0-result queries): - Search BARE IDENTIFIERS only — one identifier per `grep` query. No `load.*metadata.*Foo` style regex. - Don't use regex unless you truly need alternation; `.*`, `\d+`, `\s+` almost always return 0 results. - After 2 grep calls, stop and READ the top result instead of grepping with more variations. - Use `multi_grep` for OR logic across multiple identifiers (e.g. snake_case + PascalCase variants) in one call. - Have a specific name → `grep`. Exploring a topic / finding files → `find_files`. The `fff-mcp` binary lives at `/Users/root1/.local/bin/fff-mcp` and is registered at user scope in `~/.config/devin/config.json`. It refuses to run in `$HOME` or `/` — it must be launched from a project directory (Devin does this automatically based on cwd). Update with: `curl -fsSL https://raw.githubusercontent.com/dmtrKovalenko/fff.nvim/main/install-mcp.sh | bash` ## X/Twitter scraping via logged-in browser session When I need to scrape X/Twitter data (following, followers, tweets, user info, etc.), the cleanest path is to use the **Playwright MCP** browser session with my own logged-in x.com account, rather than spinning up twscrape's account-pool flow. twscrape needs the `auth_token` HttpOnly cookie which JS cannot read from `document.cookie`; the browser session attaches all cookies automatically. ### Flow 1. `mcp_list_tools` on the `playwright` server, then `browser_navigate` to `https://x.com`. 2. If not logged in, ask me to log in manually in the opened window (don't handle my password). 3. Once on `https://x.com/home`, read `ct0` from `document.cookie`: `document.cookie.match(/ct0=([^;]+)/)[1]` 4. Call X's GraphQL endpoints directly via `fetch()` inside `browser_evaluate`. Required headers: - `authorization: Bearer AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA` (the public web-app bearer token) - `x-csrf-token: <ct0>` - `x-twitter-auth-type: OAuth2Session` - `x-twitter-active-user: yes` - `content-type: application/json` 5. Paginate timelines by reading `content.cursorType === "Bottom"` entries and passing the value back as `variables.cursor` until it stops changing. ### Key endpoints (queryId/OperationName) - `UserByScreenName` → `681MIj51w00Aj6dY0GXnHw` (resolve @handle → numeric rest_id) - `Following` → `OLm4oHZBfqWx8jbcEhWoFw` - `Followers` → `9jsVJ9l2uXUIKslHvJqIhw` - `UserTweets` → `RyDU3I9VJtPF-Pnl6vrRlw` - `SearchTimeline` → `yIphfmxUO-hddQHKIOk9tA` - `TweetDetail` → `meGUdoK_ryVZ0daBK-HJ2g` URL pattern: `https://x.com/i/api/graphql/<queryId>/<OpName>?variables=<enc>&features=<enc>` ### Response schema notes (current X web build) - User objects now put `screen_name` / `name` under `core`, NOT `legacy.screen_name`. twscrape's parser still reads `legacy.screen_name` and returns empty — needs updating. - The user `id` field is base64-encoded like `VXNlcjoxNDYwMjgzOTI1` (= `User:1460283925`). Decode with `atob(u.id).split(':')[1]` to get the numeric rest_id. `u.rest_id` may also be present directly. - `is_blue_verified` is the verified flag. `legacy.followers_count`, `legacy.description` still exist under `legacy`. - Filter timeline entries by `content.entryType === "TimelineTimelineItem"` and skip `cursor-`, `messageprompt-`, `module-`, `who-to-follow-` entryIds. ### Features dict Use the full `GQL_FEATURES` block from twscrape's `api.py` — without it X returns `(336) The following features cannot be null`. Pass it URL-encoded as the `features` param. ### Where things live - Output CSV: `~/Downloads/utilities/sdand_following.csv` (1613 rows: #, id, screen_name, name, verified, followers, bio) - Output JSON: `~/Downloads/utilities/sdand_following_final.json` (double-encoded JSON string; parse with `json.loads(json.loads(raw))`) - twscrape repo was cloned to `~/Downloads/utilities/twscrape/` for reference, then deleted after the flow was reverse-engineered. Re-clone from https://github.com/vladkens/twscrape.git if needed. ## Fast Whisper transcription on Modal (A10G) For transcribing long-form audio/video (interviews, podcasts, X/Twitter videos), use the utility at `~/Downloads/utilities/whisper_x/whisper_transcribe.py`. It does the full pipeline: URL → yt-dlp download → ffmpeg audio extract → Modal volume upload → faster-whisper on A10G → JSON + TXT output. Validated at **2.3 min wall clock for 65 min of audio** (no caching at any layer). ### Usage Shell alias (defined in `~/.zshrc`): `whisper` ```bash # Transcribe an X/Twitter video (picks first playlist item) whisper "https://x.com/.../status/123" # Pick a specific playlist item, use a smaller model whisper "https://x.com/..." --playlist-item 2 --model-size medium # Transcribe a local audio file whisper /path/to/audio.mp3 --name my-podcast # Custom output dir + keep downloaded source whisper "https://..." --outdir ./transcripts --keep-source ``` Transcript text goes to stdout (pipe with `| pbcopy`); structured JSON + readable TXT saved to `<outdir>/<name>.json` and `<outdir>/<name>.txt`. ### Key optimizations (vs naive T4 run that took 11.7 min) - **A10G GPU** (~8x fp16 throughput vs T4; Modal ~$0.60/hr vs ~$0.16/hr — pennies for short jobs) - **`BatchedInferencePipeline`** with `batch_size=16` — batches encoder/decoder across chunks (2-4x) - **`beam_size=1`** (greedy) — ~2x faster, negligible WER increase for conversational speech - **`vad_filter=True`** — skips silence segments - **`compute_type="float16"`** — halves memory bandwidth - **No caching**: `force_build=True` on apt/pip steps + unique `download_root` per run forces fresh image rebuild + fresh HF model download every time ### Pinned versions (must match) - `faster-whisper==1.1.1` (provides `BatchedInferencePipeline`) - `ctranslate2==4.8.0` - Base image: `nvidia/cuda:12.6.3-cudnn-runtime-ubuntu22.04` (provides `libcublas.so.12`; `debian_slim` fails with `RuntimeError: Library libcublas.so.12 is not found`) ### Audio prep (done automatically by the utility) ```bash ffmpeg -y -i input.mp4 -vn -ac 1 -ar 16000 -c:a aac -b:a 64k audio.m4a ``` Mono 16kHz 64kbps AAC — a 65-min video (151 MB stream) becomes ~35 MB audio. ### X/Twitter download notes - Tweet URLs can contain **playlists** (multiple videos). Use `--playlist-item N` to pick one. - Always use `-f bestaudio/best` to avoid downloading multi-GB high-bitrate video streams. - A 65-min interview's video variant can be 2.8+ GB; audio-only is ~63 MB (128 kbps). ### Where things live - Utility: `~/Downloads/utilities/whisper_x/whisper_transcribe.py` - Strategy doc: `~/Downloads/utilities/whisper_x/STRATEGY.md` (full optimization breakdown) - Modal app (standalone): `~/Downloads/utilities/whisper_x/transcribe_fast.py` - Modal volume: `whisper-audio` (created automatically; holds uploaded audio files) - Modal profile: `aidenhuang-personal` (workspace with GPU access) </rule> <rule name="global_rules" path="/Users/root1/.codeium/windsurf/memories/global_rules.md"> </rule> </rules>

<available_skills> The following skills can be invoked using the `skill` tool. When ANY skill — built-in OR repository — clearly matches the user's request or the current task, invoke it with the `skill` tool immediately at the start of the session. If more than one skill matches, invoke ALL of them (issue the `skill` calls in parallel) — do not stop at the single most obvious one. - **web-perf**: Analyzes web performance using Chrome DevTools MCP. Measures Core Web Vitals (LCP, INP, CLS) and supplementary metrics (FCP, TBT, Speed Index), identifies render-blocking resources, network dependency chains, layout shifts, caching issues, and accessibility gaps. Use when asked to audit, profile, debug, or optimize page load performance, Lighthouse scores, or site speed. Biases towards retrieval from current documentation over pre-trained knowledge. (source: /Users/root1/.agents/skills/web-perf/SKILL.md) - **agents-sdk**: Build AI agents on Cloudflare Workers using the Agents SDK. Load when creating stateful agents, durable workflows, real-time WebSocket apps, scheduled tasks, MCP servers, chat applications, voice agents, or browser automation. Covers Agent class, state management, callable RPC, Workflows, durable execution, queues, retries, observability, and React hooks. Biases towards retrieval from Cloudflare docs over pre-trained knowledge. (source: /Users/root1/.claude/skills/agents-sdk/SKILL.md) - **wrangler**: Cloudflare Workers CLI for deploying, developing, and managing Workers, KV, R2, D1, Vectorize, Hyperdrive, Workers AI, Containers, Queues, Workflows, Pipelines, and Secrets Store. Load before running wrangler commands to ensure correct syntax and best practices. Biases towards retrieval from Cloudflare docs over pre-trained knowledge. (source: /Users/root1/.claude/skills/wrangler/SKILL.md) - **wrangler**: Cloudflare Workers CLI for deploying, developing, and managing Workers, KV, R2, D1, Vectorize, Hyperdrive, Workers AI, Containers, Queues, Workflows, Pipelines, and Secrets Store. Load before running wrangler commands to ensure correct syntax and best practices. Biases towards retrieval from Cloudflare docs over pre-trained knowledge. (source: /Users/root1/.config/devin/skills/wrangler/SKILL.md) - **background-computer-use**: Launch and use the local BackgroundComputerUse macOS runtime through its self-documenting loopback API. Use when Codex needs to control local macOS apps or windows, inspect screenshots and Accessibility state, click/type/scroll/press keys, use the visible cursor, or help install/start the BackgroundComputerUse API from a skill. (source: /Users/root1/.devin/skills/background-computer-use/SKILL.md) - **durable-objects**: Create and review Cloudflare Durable Objects. Use when building stateful coordination (chat rooms, multiplayer games, booking systems), implementing RPC methods, SQLite storage, alarms, WebSockets, or reviewing DO code for best practices. Covers Workers integration, wrangler config, and testing with Vitest. Biases towards retrieval from Cloudflare docs over pre-trained knowledge. (source: /Users/root1/.claude/skills/durable-objects/SKILL.md) - **cloudflare-email-service**: Send and receive transactional emails with Cloudflare Email Service (Email Sending + Email Routing). Use when building email sending (Workers binding or REST API), email routing, Agents SDK email handling, or integrating email into any app — Workers, Node.js, Python, Go, etc. Also use for email deliverability, SPF/DKIM/DMARC, wrangler email setup, MCP email tools, or when a coding agent needs to send emails. Even for simple requests like "add email to my Worker" — this skill has critical config details. (source: /Users/root1/.config/devin/skills/cloudflare-email-service/SKILL.md) - **durable-objects**: Create and review Cloudflare Durable Objects. Use when building stateful coordination (chat rooms, multiplayer games, booking systems), implementing RPC methods, SQLite storage, alarms, WebSockets, or reviewing DO code for best practices. Covers Workers integration, wrangler config, and testing with Vitest. Biases towards retrieval from Cloudflare docs over pre-trained knowledge. (source: /Users/root1/.config/devin/skills/durable-objects/SKILL.md) - **cloudflare-agent-setup**: (source: /Users/root1/.devin/skills/cloudflare-agent-setup/SKILL.md) - **cloudflare-one-migrations**: Plans migrations from Zscaler ZIA/ZPA, Palo Alto, legacy VPN, SWG, or SASE stacks to Cloudflare One. Use for migration assessments, policy mapping, rollout plans, and parity/gap analysis. (source: /Users/root1/.config/devin/skills/cloudflare-one-migrations/SKILL.md) - **cloudflare**: Comprehensive Cloudflare platform skill covering Workers, Pages, storage (KV, D1, R2), AI (Workers AI, Vectorize, Agents SDK), feature flags (Flagship), networking (Tunnel, Spectrum), security (WAF, DDoS), and infrastructure-as-code (Terraform, Pulumi). Use for any Cloudflare development task. Biases towards retrieval from Cloudflare docs over pre-trained knowledge. (source: /Users/root1/.agents/skills/cloudflare/SKILL.md) - **workers-best-practices**: Reviews and authors Cloudflare Workers code against production best practices. Load when writing new Workers, reviewing Worker code, configuring wrangler.jsonc, or checking for common Workers anti-patterns (streaming, floating promises, global state, secrets, bindings, observability). Biases towards retrieval from Cloudflare docs over pre-trained knowledge. (source: /Users/root1/.config/devin/skills/workers-best-practices/SKILL.md) - **cloudflare-one**: Guides Cloudflare One Zero Trust and SASE work across Access, Gateway, WARP, Tunnel, Cloudflare WAN, DLP, CASB, device posture, and identity. Use when designing, configuring, troubleshooting, or reviewing Cloudflare One deployments. Retrieval-first: use current Cloudflare docs/API schemas instead of embedded product docs. (source: /Users/root1/.agents/skills/cloudflare-one/SKILL.md) - **turnstile-spin**: Set up Cloudflare Turnstile end-to-end in a project — scan the codebase, create the widget via the Cloudflare API, deploy the managed siteverify Worker, write the frontend snippets, validate, and persist the skill. Load this when a user asks to add Turnstile, set up CAPTCHA, protect a form from bots, or fix a Turnstile integration. Mirrors developers.cloudflare.com/turnstile/spin. (source: /Users/root1/.config/devin/skills/turnstile-spin/SKILL.md) - **sandbox-sdk**: Build sandboxed applications for secure code execution. Load when building AI code execution, code interpreters, CI/CD systems, interactive dev environments, or executing untrusted code. Covers Sandbox SDK lifecycle, commands, files, code interpreter, and preview URLs. Biases towards retrieval from Cloudflare docs over pre-trained knowledge. (source: /Users/root1/.codeium/windsurf/skills/sandbox-sdk/SKILL.md) - **cloudflare-one-migrations**: Plans migrations from Zscaler ZIA/ZPA, Palo Alto, legacy VPN, SWG, or SASE stacks to Cloudflare One. Use for migration assessments, policy mapping, rollout plans, and parity/gap analysis. (source: /Users/root1/.agents/skills/cloudflare-one-migrations/SKILL.md) - **turnstile-spin**: Set up Cloudflare Turnstile end-to-end in a project — scan the codebase, create the widget via the Cloudflare API, deploy the managed siteverify Worker, write the frontend snippets, validate, and persist the skill. Load this when a user asks to add Turnstile, set up CAPTCHA, protect a form from bots, or fix a Turnstile integration. Mirrors developers.cloudflare.com/turnstile/spin. (source: /Users/root1/.codeium/windsurf/skills/turnstile-spin/SKILL.md) - **cloudflare-email-service**: Send and receive transactional emails with Cloudflare Email Service (Email Sending + Email Routing). Use when building email sending (Workers binding or REST API), email routing, Agents SDK email handling, or integrating email into any app — Workers, Node.js, Python, Go, etc. Also use for email deliverability, SPF/DKIM/DMARC, wrangler email setup, MCP email tools, or when a coding agent needs to send emails. Even for simple requests like "add email to my Worker" — this skill has critical config details. (source: /Users/root1/.agents/skills/cloudflare-email-service/SKILL.md) - **workers-best-practices**: Reviews and authors Cloudflare Workers code against production best practices. Load when writing new Workers, reviewing Worker code, configuring wrangler.jsonc, or checking for common Workers anti-patterns (streaming, floating promises, global state, secrets, bindings, observability). Biases towards retrieval from Cloudflare docs over pre-trained knowledge. (source: /Users/root1/.codeium/windsurf/skills/workers-best-practices/SKILL.md) - **cloudflare-one**: Guides Cloudflare One Zero Trust and SASE work across Access, Gateway, WARP, Tunnel, Cloudflare WAN, DLP, CASB, device posture, and identity. Use when designing, configuring, troubleshooting, or reviewing Cloudflare One deployments. Retrieval-first: use current Cloudflare docs/API schemas instead of embedded product docs. (source: /Users/root1/.config/devin/skills/cloudflare-one/SKILL.md) - **web-perf**: Analyzes web performance using Chrome DevTools MCP. Measures Core Web Vitals (LCP, INP, CLS) and supplementary metrics (FCP, TBT, Speed Index), identifies render-blocking resources, network dependency chains, layout shifts, caching issues, and accessibility gaps. Use when asked to audit, profile, debug, or optimize page load performance, Lighthouse scores, or site speed. Biases towards retrieval from current documentation over pre-trained knowledge. (source: /Users/root1/.config/devin/skills/web-perf/SKILL.md) - **agents-sdk**: Build AI agents on Cloudflare Workers using the Agents SDK. Load when creating stateful agents, durable workflows, real-time WebSocket apps, scheduled tasks, MCP servers, chat applications, voice agents, or browser automation. Covers Agent class, state management, callable RPC, Workflows, durable execution, queues, retries, observability, and React hooks. Biases towards retrieval from Cloudflare docs over pre-trained knowledge. (source: /Users/root1/.config/devin/skills/agents-sdk/SKILL.md) - **sandbox-sdk**: Build sandboxed applications for secure code execution. Load when building AI code execution, code interpreters, CI/CD systems, interactive dev environments, or executing untrusted code. Covers Sandbox SDK lifecycle, commands, files, code interpreter, and preview URLs. Biases towards retrieval from Cloudflare docs over pre-trained knowledge. (source: /Users/root1/.config/devin/skills/sandbox-sdk/SKILL.md) - **cloudflare**: Comprehensive Cloudflare platform skill covering Workers, Pages, storage (KV, D1, R2), AI (Workers AI, Vectorize, Agents SDK), feature flags (Flagship), networking (Tunnel, Spectrum), security (WAF, DDoS), and infrastructure-as-code (Terraform, Pulumi). Use for any Cloudflare development task. Biases towards retrieval from Cloudflare docs over pre-trained knowledge. (source: /Users/root1/.config/devin/skills/cloudflare/SKILL.md) - **find-skills**: Helps users discover and install agent skills when they ask questions like "how do I do X", "find a skill for X", "is there a skill that can...", or express interest in extending capabilities. This skill should be used when the user is looking for functionality that might exist as an installable skill. (source: /Users/root1/.agents/skills/find-skills/SKILL.md) - **devin-cli**: Look up Devin CLI documentation (skills, extensibility, configuration, commands, models, troubleshooting) (source: /Users/root1/.local/share/devin/cli/_versions/3000.1.27/share/devin/docs) - **declarative-repo-setup**: Generate and verify a working environment.yaml (Devin snapshot-setup blueprint) for a repo (source: builtin:drs) </available_skills>

Output from command in shell e274dc: WARNING: Your yt-dlp version (2025.12.08) is older than 90 days! It is strongly recommended to always use the latest version. You installed yt-dlp with pip or using the wheel from PyPi; Use that to update. To suppress this warning, add --no-update to your command/config. [youtube] Extracting URL: https://www.youtube.com/watch?v=y7mCxC7033A&pp=ugUEEgJlbg%3D%3D [youtube] y7mCxC7033A: Downloading webpage [youtube] y7mCxC7033A: Downloading tv client config [youtube] y7mCxC7033A: Downloading player 9b33d56a-main [youtube] y7mCxC7033A: Downloading tv player API JSON [youtube] y7mCxC7033A: Downloading android sdkless player API JSON WARNING: [youtube] y7mCxC7033A: Some tv client https formats have been skipped as they are missing a url. YouTube may have enabled the SABR-only or Server-Side Ad Placement experiment for the current session. See https://github.com/yt-dlp/yt-dlp/issues/12482 for more details [youtube] [jsc:deno] Solving JS challenges using deno WARNING: [youtube] [jsc] Remote components challenge solver script (deno) and NPM package (deno) were skipped. These may be required to solve JS challenges. You can enable these downloads with --remote-components ejs:github (recommended) or --remote-components ejs:npm , respectively. For more information and alternatives, refer to https://github.com/yt-dlp/yt-dlp/wiki/EJS WARNING: [youtube] y7mCxC7033A: n challenge solving failed: Some formats may be missing. Ensure you have a supported JavaScript runtime and challenge solver script distribution installed. Review any warnings presented before this message. For more details, refer to https://github.com/yt-dlp/yt-dlp/wiki/EJS WARNING: [youtube] y7mCxC7033A: Some web client https formats have been skipped as they are missing a url. YouTube is forcing SABR streaming for this client. See https://github.com/yt-dlp/yt-dlp/issues/12482 for more details [info] Available automatic captions for y7mCxC7033A: Language Name Formats ab-en Abkhazian from English vtt, srt, ttml, srv3, srv2, srv1, json3 aa-en Afar from English vtt, srt, ttml, srv3, srv2, srv1, json3 af-en Afrikaans from English vtt, srt, ttml, srv3, srv2, srv1, json3 ak-en Akan from English vtt, srt, ttml, srv3, srv2, srv1, json3 sq-en Albanian from English vtt, srt, ttml, srv3, srv2, srv1, json3 am-en Amharic from English vtt, srt, ttml, srv3, srv2, srv1, json3 ar-en Arabic from English vtt, srt, ttml, srv3, srv2, srv1, json3 hy-en Armenian from English vtt, srt, ttml, srv3, srv2, srv1, json3 as-en Assamese from English vtt, srt, ttml, srv3, srv2, srv1, json3 ay-en Aymara from English vtt, srt, ttml, srv3, srv2, srv1, json3 az-en Azerbaijani from English vtt, srt, ttml, srv3, srv2, srv1, json3 bn-en Bangla from English vtt, srt, ttml, srv3, srv2, srv1, json3 ba-en Bashkir from English vtt, srt, ttml, srv3, srv2, srv1, json3 eu-en Basque from English vtt, srt, ttml, srv3, srv2, srv1, json3 be-en Belarusian from English vtt, srt, ttml, srv3, srv2, srv1, json3 bho-en Bhojpuri from English vtt, srt, ttml, srv3, srv2, srv1, json3 bs-en Bosnian from English vtt, srt, ttml, srv3, srv2, srv1, json3 br-en Breton from English vtt, srt, ttml, srv3, srv2, srv1, json3 bg-en Bulgarian from English vtt, srt, ttml, srv3, srv2, srv1, json3 my-en Burmese from English vtt, srt, ttml, srv3, srv2, srv1, json3 ca-en Catalan from English vtt, srt, ttml, srv3, srv2, srv1, json3 ceb-en Cebuano from English vtt, srt, ttml, srv3, srv2, srv1, json3 zh-Hans-en Chinese (Simplified) from English vtt, srt, ttml, srv3, srv2, srv1, json3 zh-Hant-en Chinese (Traditional) from English vtt, srt, ttml, srv3, srv2, srv1, json3 co-en Corsican from English vtt, srt, ttml, srv3, srv2, srv1, json3 hr-en Croatian from English vtt, srt, ttml, srv3, srv2, srv1, json3 cs-en Czech from English vtt, srt, ttml, srv3, srv2, srv1, json3 da-en Danish from English vtt, srt, ttml, srv3, srv2, srv1, json3 dv-en Divehi from English vtt, srt, ttml, srv3, srv2, srv1, json3 nl-en Dutch from English vtt, srt, ttml, srv3, srv2, srv1, json3 dz-en Dzongkha from English vtt, srt, ttml, srv3, srv2, srv1, json3 en-en English from English vtt, srt, ttml, srv3, srv2, srv1, json3 eo-en Esperanto from English vtt, srt, ttml, srv3, srv2, srv1, json3 et-en Estonian from English vtt, srt, ttml, srv3, srv2, srv1, json3 ee-en Ewe from English vtt, srt, ttml, srv3, srv2, srv1, json3 fo-en Faroese from English vtt, srt, ttml, srv3, srv2, srv1, json3 fj-en Fijian from English vtt, srt, ttml, srv3, srv2, srv1, json3 fil-en Filipino from English vtt, srt, ttml, srv3, srv2, srv1, json3 fi-en Finnish from English vtt, srt, ttml, srv3, srv2, srv1, json3 fr-en French from English vtt, srt, ttml, srv3, srv2, srv1, json3 gaa-en Ga from English vtt, srt, ttml, srv3, srv2, srv1, json3 gl-en Galician from English vtt, srt, ttml, srv3, srv2, srv1, json3 lg-en Ganda from English vtt, srt, ttml, srv3, srv2, srv1, json3 ka-en Georgian from English vtt, srt, ttml, srv3, srv2, srv1, json3 de-en German from English vtt, srt, ttml, srv3, srv2, srv1, json3 el-en Greek from English vtt, srt, ttml, srv3, srv2, srv1, json3 gn-en Guarani from English vtt, srt, ttml, srv3, srv2, srv1, json3 gu-en Gujarati from English vtt, srt, ttml, srv3, srv2, srv1, json3 ht-en Haitian Creole from English vtt, srt, ttml, srv3, srv2, srv1, json3 ha-en Hausa from English vtt, srt, ttml, srv3, srv2, srv1, json3 haw-en Hawaiian from English vtt, srt, ttml, srv3, srv2, srv1, json3 iw-en Hebrew from English vtt, srt, ttml, srv3, srv2, srv1, json3 hi-en Hindi from English vtt, srt, ttml, srv3, srv2, srv1, json3 hmn-en Hmong from English vtt, srt, ttml, srv3, srv2, srv1, json3 hu-en Hungarian from English vtt, srt, ttml, srv3, srv2, srv1, json3 is-en Icelandic from English vtt, srt, ttml, srv3, srv2, srv1, json3 ig-en Igbo from English vtt, srt, ttml, srv3, srv2, srv1, json3 id-en Indonesian from English vtt, srt, ttml, srv3, srv2, srv1, json3 iu-en Inuktitut from English vtt, srt, ttml, srv3, srv2, srv1, json3 ga-en Irish from English vtt, srt, ttml, srv3, srv2, srv1, json3 it-en Italian from English vtt, srt, ttml, srv3, srv2, srv1, json3 ja-en Japanese from English vtt, srt, ttml, srv3, srv2, srv1, json3 jv-en Javanese from English vtt, srt, ttml, srv3, srv2, srv1, json3 kl-en Kalaallisut from English vtt, srt, ttml, srv3, srv2, srv1, json3 kn-en Kannada from English vtt, srt, ttml, srv3, srv2, srv1, json3 kk-en Kazakh from English vtt, srt, ttml, srv3, srv2, srv1, json3 kha-en Khasi from English vtt, srt, ttml, srv3, srv2, srv1, json3 km-en Khmer from English vtt, srt, ttml, srv3, srv2, srv1, json3 rw-en Kinyarwanda from English vtt, srt, ttml, srv3, srv2, srv1, json3 ko-en Korean from English vtt, srt, ttml, srv3, srv2, srv1, json3 kri-en Krio from English vtt, srt, ttml, srv3, srv2, srv1, json3 ku-en Kurdish from English vtt, srt, ttml, srv3, srv2, srv1, json3 ky-en Kyrgyz from English vtt, srt, ttml, srv3, srv2, srv1, json3 lo-en Lao from English vtt, srt, ttml, srv3, srv2, srv1, json3 la-en Latin from English vtt, srt, ttml, srv3, srv2, srv1, json3 lv-en Latvian from English vtt, srt, ttml, srv3, srv2, srv1, json3 ln-en Lingala from English vtt, srt, ttml, srv3, srv2, srv1, json3 lt-en Lithuanian from English vtt, srt, ttml, srv3, srv2, srv1, json3 lua-en Luba-Lulua from English vtt, srt, ttml, srv3, srv2, srv1, json3 luo-en Luo from English vtt, srt, ttml, srv3, srv2, srv1, json3 lb-en Luxembourgish from English vtt, srt, ttml, srv3, srv2, srv1, json3 mk-en Macedonian from English vtt, srt, ttml, srv3, srv2, srv1, json3 mg-en Malagasy from English vtt, srt, ttml, srv3, srv2, srv1, json3 ms-en Malay from English vtt, srt, ttml, srv3, srv2, srv1, json3 ml-en Malayalam from English vtt, srt, ttml, srv3, srv2, srv1, json3 mt-en Maltese from English vtt, srt, ttml, srv3, srv2, srv1, json3 gv-en Manx from English vtt, srt, ttml, srv3, srv2, srv1, json3 mi-en Māori from English vtt, srt, ttml, srv3, srv2, srv1, json3 mr-en Marathi from English vtt, srt, ttml, srv3, srv2, srv1, json3 mn-en Mongolian from English vtt, srt, ttml, srv3, srv2, srv1, json3 mfe-en Morisyen from English vtt, srt, ttml, srv3, srv2, srv1, json3 ne-en Nepali from English vtt, srt, ttml, srv3, srv2, srv1, json3 new-en Newari from English vtt, srt, ttml, srv3, srv2, srv1, json3 nso-en Northern Sotho from English vtt, srt, ttml, srv3, srv2, srv1, json3 no-en Norwegian from English vtt, srt, ttml, srv3, srv2, srv1, json3 ny-en Nyanja from English vtt, srt, ttml, srv3, srv2, srv1, json3 oc-en Occitan from English vtt, srt, ttml, srv3, srv2, srv1, json3 or-en Odia from English vtt, srt, ttml, srv3, srv2, srv1, json3 om-en Oromo from English vtt, srt, ttml, srv3, srv2, srv1, json3 os-en Ossetic from English vtt, srt, ttml, srv3, srv2, srv1, json3 pam-en Pampanga from English vtt, srt, ttml, srv3, srv2, srv1, json3 ps-en Pashto from English vtt, srt, ttml, srv3, srv2, srv1, json3 fa-en Persian from English vtt, srt, ttml, srv3, srv2, srv1, json3 pl-en Polish from English vtt, srt, ttml, srv3, srv2, srv1, json3 pt-en Portuguese from English vtt, srt, ttml, srv3, srv2, srv1, json3 pt-PT-en Portuguese (Portugal) from English vtt, srt, ttml, srv3, srv2, srv1, json3 pa-en Punjabi from English vtt, srt, ttml, srv3, srv2, srv1, json3 qu-en Quechua from English vtt, srt, ttml, srv3, srv2, srv1, json3 ro-en Romanian from English vtt, srt, ttml, srv3, srv2, srv1, json3 rn-en Rundi from English vtt, srt, ttml, srv3, srv2, srv1, json3 ru-en Russian from English vtt, srt, ttml, srv3, srv2, srv1, json3 sm-en Samoan from English vtt, srt, ttml, srv3, srv2, srv1, json3 sg-en Sango from English vtt, srt, ttml, srv3, srv2, srv1, json3 sa-en Sanskrit from English vtt, srt, ttml, srv3, srv2, srv1, json3 gd-en Scottish Gaelic from English vtt, srt, ttml, srv3, srv2, srv1, json3 sr-en Serbian from English vtt, srt, ttml, srv3, srv2, srv1, json3 crs-en Seselwa Creole French from English vtt, srt, ttml, srv3, srv2, srv1, json3 sn-en Shona from English vtt, srt, ttml, srv3, srv2, srv1, json3 sd-en Sindhi from English vtt, srt, ttml, srv3, srv2, srv1, json3 si-en Sinhala from English vtt, srt, ttml, srv3, srv2, srv1, json3 sk-en Slovak from English vtt, srt, ttml, srv3, srv2, srv1, json3 sl-en Slovenian from English vtt, srt, ttml, srv3, srv2, srv1, json3 so-en Somali from English vtt, srt, ttml, srv3, srv2, srv1, json3 st-en Southern Sotho from English vtt, srt, ttml, srv3, srv2, srv1, json3 es-en Spanish from English vtt, srt, ttml, srv3, srv2, srv1, json3 su-en Sundanese from English vtt, srt, ttml, srv3, srv2, srv1, json3 sw-en Swahili from English vtt, srt, ttml, srv3, srv2, srv1, json3 ss-en Swati from English vtt, srt, ttml, srv3, srv2, srv1, json3 sv-en Swedish from English vtt, srt, ttml, srv3, srv2, srv1, json3 tg-en Tajik from English vtt, srt, ttml, srv3, srv2, srv1, json3 ta-en Tamil from English vtt, srt, ttml, srv3, srv2, srv1, json3 tt-en Tatar from English vtt, srt, ttml, srv3, srv2, srv1, json3 te-en Telugu from English vtt, srt, ttml, srv3, srv2, srv1, json3 th-en Thai from English vtt, srt, ttml, srv3, srv2, srv1, json3 bo-en Tibetan from English vtt, srt, ttml, srv3, srv2, srv1, json3 ti-en Tigrinya from English vtt, srt, ttml, srv3, srv2, srv1, json3 to-en Tongan from English vtt, srt, ttml, srv3, srv2, srv1, json3 ts-en Tsonga from English vtt, srt, ttml, srv3, srv2, srv1, json3 tn-en Tswana from English vtt, srt, ttml, srv3, srv2, srv1, json3 tum-en Tumbuka from English vtt, srt, ttml, srv3, srv2, srv1, json3 tr-en Turkish from English vtt, srt, ttml, srv3, srv2, srv1, json3 tk-en Turkmen from English vtt, srt, ttml, srv3, srv2, srv1, json3 uk-en Ukrainian from English vtt, srt, ttml, srv3, srv2, srv1, json3 ur-en Urdu from English vtt, srt, ttml, srv3, srv2, srv1, json3 ug-en Uyghur from English vtt, srt, ttml, srv3, srv2, srv1, json3 uz-en Uzbek from English vtt, srt, ttml, srv3, srv2, srv1, json3 ve-en Venda from English vtt, srt, ttml, srv3, srv2, srv1, json3 vi-en Vietnamese from English vtt, srt, ttml, srv3, srv2, srv1, json3 war-en Waray from English vtt, srt, ttml, srv3, srv2, srv1, json3 cy-en Welsh from English vtt, srt, ttml, srv3, srv2, srv1, json3 fy-en Western Frisian from English vtt, srt, ttml, srv3, srv2, srv1, json3 wo-en Wolof from English vtt, srt, ttml, srv3, srv2, srv1, json3 xh-en Xhosa from English vtt, srt, ttml, srv3, srv2, srv1, json3 yi-en Yiddish from English vtt, srt, ttml, srv3, srv2, srv1, json3 yo-en Yoruba from English vtt, srt, ttml, srv3, srv2, srv1, json3 zu-en Zulu from English vtt, srt, ttml, srv3, srv2, srv1, json3 ab Abkhazian vtt, srt, ttml, srv3, srv2, srv1, json3 aa Afar vtt, srt, ttml, srv3, srv2, srv1, json3 af Afrikaans vtt, srt, ttml, srv3, srv2, srv1, json3 ak Akan vtt, srt, ttml, srv3, srv2, srv1, json3 sq Albanian vtt, srt, ttml, srv3, srv2, srv1, json3 am Amharic vtt, srt, ttml, srv3, srv2, srv1, json3 ar Arabic vtt, srt, ttml, srv3, srv2, srv1, json3 hy Armenian vtt, srt, ttml, srv3, srv2, srv1, json3 as Assamese vtt, srt, ttml, srv3, srv2, srv1, json3 ay Aymara vtt, srt, ttml, srv3, srv2, srv1, json3 az Azerbaijani vtt, srt, ttml, srv3, srv2, srv1, json3 bn Bangla vtt, srt, ttml, srv3, srv2, srv1, json3 ba Bashkir vtt, srt, ttml, srv3, srv2, srv1, json3 eu Basque vtt, srt, ttml, srv3, srv2, srv1, json3 be Belarusian vtt, srt, ttml, srv3, srv2, srv1, json3 bho Bhojpuri vtt, srt, ttml, srv3, srv2, srv1, json3 bs Bosnian vtt, srt, ttml, srv3, srv2, srv1, json3 br Breton vtt, srt, ttml, srv3, srv2, srv1, json3 bg Bulgarian vtt, srt, ttml, srv3, srv2, srv1, json3 my Burmese vtt, srt, ttml, srv3, srv2, srv1, json3 ca Catalan vtt, srt, ttml, srv3, srv2, srv1, json3 ceb Cebuano vtt, srt, ttml, srv3, srv2, srv1, json3 zh-Hans Chinese (Simplified) vtt, srt, ttml, srv3, srv2, srv1, json3 zh-Hant Chinese (Traditional) vtt, srt, ttml, srv3, srv2, srv1, json3 co Corsican vtt, srt, ttml, srv3, srv2, srv1, json3 hr Croatian vtt, srt, ttml, srv3, srv2, srv1, json3 cs Czech vtt, srt, ttml, srv3, srv2, srv1, json3 da Danish vtt, srt, ttml, srv3, srv2, srv1, json3 dv Divehi vtt, srt, ttml, srv3, srv2, srv1, json3 nl Dutch vtt, srt, ttml, srv3, srv2, srv1, json3 dz Dzongkha vtt, srt, ttml, srv3, srv2, srv1, json3 en-orig English (Original) vtt, srt, ttml, srv3, srv2, srv1, json3 en English vtt, srt, ttml, srv3, srv2, srv1, json3 eo Esperanto vtt, srt, ttml, srv3, srv2, srv1, json3 et Estonian vtt, srt, ttml, srv3, srv2, srv1, json3 ee Ewe vtt, srt, ttml, srv3, srv2, srv1, json3 fo Faroese vtt, srt, ttml, srv3, srv2, srv1, json3 fj Fijian vtt, srt, ttml, srv3, srv2, srv1, json3 fil Filipino vtt, srt, ttml, srv3, srv2, srv1, json3 fi Finnish vtt, srt, ttml, srv3, srv2, srv1, json3 fr French vtt, srt, ttml, srv3, srv2, srv1, json3 gaa Ga vtt, srt, ttml, srv3, srv2, srv1, json3 gl Galician vtt, srt, ttml, srv3, srv2, srv1, json3 lg Ganda vtt, srt, ttml, srv3, srv2, srv1, json3 ka Georgian vtt, srt, ttml, srv3, srv2, srv1, json3 de German vtt, srt, ttml, srv3, srv2, srv1, json3 el Greek vtt, srt, ttml, srv3, srv2, srv1, json3 gn Guarani vtt, srt, ttml, srv3, srv2, srv1, json3 gu Gujarati vtt, srt, ttml, srv3, srv2, srv1, json3 ht Haitian Creole vtt, srt, ttml, srv3, srv2, srv1, json3 ha Hausa vtt, srt, ttml, srv3, srv2, srv1, json3 haw Hawaiian vtt, srt, ttml, srv3, srv2, srv1, json3 iw Hebrew vtt, srt, ttml, srv3, srv2, srv1, json3 hi Hindi vtt, srt, ttml, srv3, srv2, srv1, json3 hmn Hmong vtt, srt, ttml, srv3, srv2, srv1, json3 hu Hungarian vtt, srt, ttml, srv3, srv2, srv1, json3 is Icelandic vtt, srt, ttml, srv3, srv2, srv1, json3 ig Igbo vtt, srt, ttml, srv3, srv2, srv1, json3 id Indonesian vtt, srt, ttml, srv3, srv2, srv1, json3 iu Inuktitut vtt, srt, ttml, srv3, srv2, srv1, json3 ga Irish vtt, srt, ttml, srv3, srv2, srv1, json3 it Italian vtt, srt, ttml, srv3, srv2, srv1, json3 ja Japanese vtt, srt, ttml, srv3, srv2, srv1, json3 jv Javanese vtt, srt, ttml, srv3, srv2, srv1, json3 kl Kalaallisut vtt, srt, ttml, srv3, srv2, srv1, json3 kn Kannada vtt, srt, ttml, srv3, srv2, srv1, json3 kk Kazakh vtt, srt, ttml, srv3, srv2, srv1, json3 kha Khasi vtt, srt, ttml, srv3, srv2, srv1, json3 km Khmer vtt, srt, ttml, srv3, srv2, srv1, json3 rw Kinyarwanda vtt, srt, ttml, srv3, srv2, srv1, json3 ko Korean vtt, srt, ttml, srv3, srv2, srv1, json3 kri Krio vtt, srt, ttml, srv3, srv2, srv1, json3 ku Kurdish vtt, srt, ttml, srv3, srv2, srv1, json3 ky Kyrgyz vtt, srt, ttml, srv3, srv2, srv1, json3 lo Lao vtt, srt, ttml, srv3, srv2, srv1, json3 la Latin vtt, srt, ttml, srv3, srv2, srv1, json3 lv Latvian vtt, srt, ttml, srv3, srv2, srv1, json3 ln Lingala vtt, srt, ttml, srv3, srv2, srv1, json3 lt Lithuanian vtt, srt, ttml, srv3, srv2, srv1, json3 lua Luba-Lulua vtt, srt, ttml, srv3, srv2, srv1, json3 luo Luo vtt, srt, ttml, srv3, srv2, srv1, json3 lb Luxembourgish vtt, srt, ttml, srv3, srv2, srv1, json3 mk Macedonian vtt, srt, ttml, srv3, srv2, srv1, json3 mg Malagasy vtt, srt, ttml, srv3, srv2, srv1, json3 ms Malay vtt, srt, ttml, srv3, srv2, srv1, json3 ml Malayalam vtt, srt, ttml, srv3, srv2, srv1, json3 mt Maltese vtt, srt, ttml, srv3, srv2, srv1, json3 gv Manx vtt, srt, ttml, srv3, srv2, srv1, json3 mi Māori vtt, srt, ttml, srv3, srv2, srv1, json3 mr Marathi vtt, srt, ttml, srv3, srv2, srv1, json3 mn Mongolian vtt, srt, ttml, srv3, srv2, srv1, json3 mfe Morisyen vtt, srt, ttml, srv3, srv2, srv1, json3 ne Nepali vtt, srt, ttml, srv3, srv2, srv1, json3 new Newari vtt, srt, ttml, srv3, srv2, srv1, json3 nso Northern Sotho vtt, srt, ttml, srv3, srv2, srv1, json3 no Norwegian vtt, srt, ttml, srv3, srv2, srv1, json3 ny Nyanja vtt, srt, ttml, srv3, srv2, srv1, json3 oc Occitan vtt, srt, ttml, srv3, srv2, srv1, json3 or Odia vtt, srt, ttml, srv3, srv2, srv1, json3 om Oromo vtt, srt, ttml, srv3, srv2, srv1, json3 os Ossetic vtt, srt, ttml, srv3, srv2, srv1, json3 pam Pampanga vtt, srt, ttml, srv3, srv2, srv1, json3 ps Pashto vtt, srt, ttml, srv3, srv2, srv1, json3 fa Persian vtt, srt, ttml, srv3, srv2, srv1, json3 pl Polish vtt, srt, ttml, srv3, srv2, srv1, json3 pt Portuguese vtt, srt, ttml, srv3, srv2, srv1, json3 pt-PT Portuguese (Portugal) vtt, srt, ttml, srv3, srv2, srv1, json3 pa Punjabi vtt, srt, ttml, srv3, srv2, srv1, json3 qu Quechua vtt, srt, ttml, srv3, srv2, srv1, json3 ro Romanian vtt, srt, ttml, srv3, srv2, srv1, json3 rn Rundi vtt, srt, ttml, srv3, srv2, srv1, json3 ru Russian vtt, srt, ttml, srv3, srv2, srv1, json3 sm Samoan vtt, srt, ttml, srv3, srv2, srv1, json3 sg Sango vtt, srt, ttml, srv3, srv2, srv1, json3 sa Sanskrit vtt, srt, ttml, srv3, srv2, srv1, json3 gd Scottish Gaelic vtt, srt, ttml, srv3, srv2, srv1, json3 sr Serbian vtt, srt, ttml, srv3, srv2, srv1, json3 crs Seselwa Creole French vtt, srt, ttml, srv3, srv2, srv1, json3 sn Shona vtt, srt, ttml, srv3, srv2, srv1, json3 sd Sindhi vtt, srt, ttml, srv3, srv2, srv1, json3 si Sinhala vtt, srt, ttml, srv3, srv2, srv1, json3 sk Slovak vtt, srt, ttml, srv3, srv2, srv1, json3 sl Slovenian vtt, srt, ttml, srv3, srv2, srv1, json3 so Somali vtt, srt, ttml, srv3, srv2, srv1, json3 st Southern Sotho vtt, srt, ttml, srv3, srv2, srv1, json3 es Spanish vtt, srt, ttml, srv3, srv2, srv1, json3 su Sundanese vtt, srt, ttml, srv3, srv2, srv1, json3 sw Swahili vtt, srt, ttml, srv3, srv2, srv1, json3 ss Swati vtt, srt, ttml, srv3, srv2, srv1, json3 sv Swedish vtt, srt, ttml, srv3, srv2, srv1, json3 tg Tajik vtt, srt, ttml, srv3, srv2, srv1, json3 ta Tamil vtt, srt, ttml, srv3, srv2, srv1, json3 tt Tatar vtt, srt, ttml, srv3, srv2, srv1, json3 te Telugu vtt, srt, ttml, srv3, srv2, srv1, json3 th Thai vtt, srt, ttml, srv3, srv2, srv1, json3 bo Tibetan vtt, srt, ttml, srv3, srv2, srv1, json3 ti Tigrinya vtt, srt, ttml, srv3, srv2, srv1, json3 to Tongan vtt, srt, ttml, srv3, srv2, srv1, json3 ts Tsonga vtt, srt, ttml, srv3, srv2, srv1, json3 tn Tswana vtt, srt, ttml, srv3, srv2, srv1, json3 tum Tumbuka vtt, srt, ttml, srv3, srv2, srv1, json3 tr Turkish vtt, srt, ttml, srv3, srv2, srv1, json3 tk Turkmen vtt, srt, ttml, srv3, srv2, srv1, json3 uk Ukrainian vtt, srt, ttml, srv3, srv2, srv1, json3 ur Urdu vtt, srt, ttml, srv3, srv2, srv1, json3 ug Uyghur vtt, srt, ttml, srv3, srv2, srv1, json3 uz Uzbek vtt, srt, ttml, srv3, srv2, srv1, json3 ve Venda vtt, srt, ttml, srv3, srv2, srv1, json3 vi Vietnamese vtt, srt, ttml, srv3, srv2, srv1, json3 war Waray vtt, srt, ttml, srv3, srv2, srv1, json3 cy Welsh vtt, srt, ttml, srv3, srv2, srv1, json3 fy Western Frisian vtt, srt, ttml, srv3, srv2, srv1, json3 wo Wolof vtt, srt, ttml, srv3, srv2, srv1, json3 xh Xhosa vtt, srt, ttml, srv3, srv2, srv1, json3 yi Yiddish vtt, srt, ttml, srv3, srv2, srv1, json3 yo Yoruba vtt, srt, ttml, srv3, srv2, srv1, json3 zu Zulu vtt, srt, ttml, srv3, srv2, srv1, json3 [info] Available subtitles for y7mCxC7033A: Language Name Formats en English vtt, srt, ttml, srv3, srv2, srv1, json3 Exit code: 0

{ "command": "mkdir -p /tmp/youtube_summary && yt-dlp --skip-download --write-subs --sub-langs en --sub-format srt --convert-subs srt -o \"/tmp/youtube_summary/%(title)s.%(ext)s\" \"https://www.youtube.com/watch?v=y7mCxC7033A&pp=ugUEEgJlbg%3D%3D\"", "timeout": 60000 }

Output from command in shell 43a248: WARNING: Your yt-dlp version (2025.12.08) is older than 90 days! It is strongly recommended to always use the latest version. You installed yt-dlp with pip or using the wheel from PyPi; Use that to update. To suppress this warning, add --no-update to your command/config. [youtube] Extracting URL: https://www.youtube.com/watch?v=y7mCxC7033A&pp=ugUEEgJlbg%3D%3D [youtube] y7mCxC7033A: Downloading webpage [youtube] y7mCxC7033A: Downloading tv client config [youtube] y7mCxC7033A: Downloading player 9b33d56a-main [youtube] y7mCxC7033A: Downloading tv player API JSON [youtube] y7mCxC7033A: Downloading android sdkless player API JSON [youtube] [jsc:deno] Solving JS challenges using deno WARNING: [youtube] [jsc] Remote components challenge solver script (deno) and NPM package (deno) were skipped. These may be required to solve JS challenges. You can enable these downloads with --remote-components ejs:github (recommended) or --remote-components ejs:npm , respectively. For more information and alternatives, refer to https://github.com/yt-dlp/yt-dlp/wiki/EJS WARNING: [youtube] y7mCxC7033A: n challenge solving failed: Some formats may be missing. Ensure you have a supported JavaScript runtime and challenge solver script distribution installed. Review any warnings presented before this message. For more details, refer to https://github.com/yt-dlp/yt-dlp/wiki/EJS [info] y7mCxC7033A: Downloading subtitles: en [info] y7mCxC7033A: Downloading 1 format(s): 139-11 [info] Writing video subtitles to: /tmp/youtube_summary/The best mousepads you can get - Artisan buyer's guide.en.srt [download] Destination: /tmp/youtube_summary/The best mousepads you can get - Artisan buyer's guide.en.srt [download] 1.00KiB at Unknown B/s (00:00:00) [download] 3.00KiB at Unknown B/s (00:00:00) [download] 7.00KiB at Unknown B/s (00:00:00) [download] 15.00KiB at 5.41MiB/s (00:00:00) [download] 31.00KiB at 1.86MiB/s (00:00:00) [download] 49.10KiB at 2.31MiB/s (00:00:00) [download] 100% of 49.10KiB in 00:00:00 at 393.20KiB/s [SubtitlesConvertor] Converting subtitles [SubtitlesConvertor] Subtitle file for srt is already in the requested format Exit code: 0

<file-view path="/tmp/youtube_summary/The best mousepads you can get - Artisan buyer's guide.en.srt" start_line="1" end_line="767" total_lines="1886"> 1|1 2|00:00:00,240 --> 00:00:05,920 3|If you've ever looked for a premium mousepad 4|you've probably seen these. Artisan mousepads. 5| 6|2 7|00:00:05,920 --> 00:00:11,080 8|They have almost become a universal recommendation 9|and for good reason! I've been maining something 10| 11|3 12|00:00:11,080 --> 00:00:15,840 13|from artisan for almost 4 years straight at this 14|point, even though I've tried so many different 15| 16|4 17|00:00:15,840 --> 00:00:20,920 18|fps games throughout that time period. Which is 19|a clue to the reason I think they are as popular 20| 21|5 22|00:00:20,920 --> 00:00:26,720 23|as they are, they have a product to fill every 24|niche. From slower pads to aid in stability for 25| 26|6 27|00:00:26,720 --> 00:00:31,800 28|something like valorant to faster ones for games 29|with more varied movement and all the common and 30| 31|7 32|00:00:31,800 --> 00:00:36,880 33|weird use cases in between. But before I talk 34|about all of the surfaces in more detail I want 35| 36|8 37|00:00:36,880 --> 00:00:41,080 38|to really quickly explain some features that 39|are present on every artisan pad because the 40| 41|9 42|00:00:41,080 --> 00:00:47,040 43|wide variety of surfaces on offer here wouldn't 44|matter if the pads weren't actually good. 45| 46| 47|10 48|00:00:47,040 --> 00:00:51,800 49|The edge stitching of a mousepad refers to this 50|bit here and was implemented to stop the cloth 51| 52|11 53|00:00:51,800 --> 00:00:57,480 54|in pads from fraying outwards and it improves 55|durability. Early or cheaper attempts at this 56| 57|12 58|00:00:57,480 --> 00:01:02,880 59|had an issue though, the stitching would sit above 60|the physical surface of the pad so you'd feel and 61| 62|13 63|00:01:02,880 --> 00:01:07,800 64|sometimes get stuck on it when trying to glide 65|your arm across. Artisan's stitching is below 66| 67|14 68|00:01:07,800 --> 00:01:12,440 69|the surface so this doesn't happen and although 70|this isn't that rare these days, they were the 71| 72|15 73|00:01:12,440 --> 00:01:17,760 74|first to implement it as far as I know and are 75|still well up there in terms of quality. I've 76| 77|16 78|00:01:17,760 --> 00:01:24,280 79|also found their pads to be more durable than most 80|other cloth pads, my zero softs, yes, plural, last 81| 82|17 83|00:01:24,280 --> 00:01:28,800 84|about 9 months before significantly slowing down 85|which is a lot better than something like a zowie 86| 87|18 88|00:01:28,800 --> 00:01:34,440 89|g-sr-se which takes maybe 3. The bases of these 90|pads are great too, they are made from a different 91| 92|19 93|00:01:34,440 --> 00:01:40,960 94|material to most that's more sticky so if you've 95|ever experienced this, that won't happen here. 96| 97| 98|20 99|00:01:40,960 --> 00:01:44,440 100|The base of a mousepad isn't actually only 101|relevant for how well it can stick to your 102| 103|21 104|00:01:44,440 --> 00:01:49,600 105|desk though. The firmness of the base changes 106|a lot about how aiming feels when using the pad 107| 108|22 109|00:01:49,600 --> 00:01:55,120 110|and this is why artisan manufactures each of 111|their surfaces in three variants, xsoft soft 112| 113|23 114|00:01:55,120 --> 00:02:00,880 115|and mid which do all feel pretty distinct. As 116|a general rule of thumb I would recommend soft, 117| 118|24 119|00:02:00,880 --> 00:02:05,640 120|it's my personal favourite and I think the safest 121|of the bunch but there certainly are use cases for 122| 123|25 124|00:02:05,640 --> 00:02:10,040 125|mid and xsoft as well. I know a lot of people 126|struggle with trying to manage tension during 127| 128|26 129|00:02:10,040 --> 00:02:14,240 130|stressful situations in game, and this can lead 131|to applying pressure down into the mousepad 132| 133|27 134|00:02:14,240 --> 00:02:19,880 135|either as a reflex or as a way to alleviate that 136|shakiness that nerves can cause. But when this 137| 138|28 139|00:02:19,880 --> 00:02:25,240 140|is done without intent or control behind it, all 141|this downwards pressure does is make aiming feel 142| 143|29 144|00:02:25,240 --> 00:02:30,800 145|very inconsistent. Going with a mid pad can help 146|negate this issue, the pad won't slow as much from 147| 148|30 149|00:02:30,800 --> 00:02:36,120 150|that pressure which can potentially give it a more 151|consistent feeling glide. This is why the speed of 152| 153|31 154|00:02:36,120 --> 00:02:41,160 155|each pad changes with the firmness, even though 156|the surfaces across all versions are identical, 157| 158|32 159|00:02:41,160 --> 00:02:47,320 160|the mid versions of each will feel slightly faster 161|due to that lack of slowdown. That said, variation 162| 163|33 164|00:02:47,320 --> 00:02:52,760 165|of downwards pressure isn't strictly a downside, 166|personally I lean into it sometimes, for example 167| 168|34 169|00:02:52,760 --> 00:02:57,720 170|I might press into the pad at the end of a flick 171|to bring my mouse to a stop without any shaking. 172| 173|35 174|00:02:57,720 --> 00:03:02,240 175|This works well on soft pads but if this is 176|something you've based your aiming style around, 177| 178|36 179|00:03:02,240 --> 00:03:08,120 180|an xsoft pad could help you utilise it further. 181|The other benefit of xsoft is just comfort, 182| 183|37 184|00:03:08,120 --> 00:03:12,240 185|it's super plush, it can almost feel like you're 186|resting your arm on a cushion at times especially 187| 188|38 189|00:03:12,240 --> 00:03:17,760 190|when compared to the mid pads that can be a little 191|firm and uncomfortable occasionally. Xsoft isn't 192| 193|39 194|00:03:17,760 --> 00:03:21,720 195|without it's downsides though, it's very hard 196|to manage downwards pressure well enough to 197| 198|40 199|00:03:21,720 --> 00:03:26,560 200|avoid slowdown and I personally have found them 201|next to unusable with smaller mouse skates, the 202| 203|41 204|00:03:26,560 --> 00:03:32,200 205|surface area just isn't enough to hold the mouse 206|far up enough to not scratch against the pad. So, 207| 208|42 209|00:03:32,200 --> 00:03:37,000 210|soft is the safest option but if the benefits 211|of either xsoft or mid appeal to you, they 212| 213|43 214|00:03:37,000 --> 00:03:43,280 215|certainly work well and are worth considering. 216|I'm usually quite critical of products that try 217| 218|44 219|00:03:43,280 --> 00:03:48,040 220|to appeal to everyone. Mice like the G Pro 221|Superlight for example are good and people 222| 223|45 224|00:03:48,040 --> 00:03:52,720 225|rightfully love it, but when a product tries to 226|fill a wide range of use cases it typically has 227| 228|46 229|00:03:52,720 --> 00:03:57,920 230|to sacrifice excelling in any of them. Maybe those 231|people would like a more specialised mouse more, 232| 233|47 234|00:03:57,920 --> 00:04:03,760 235|but the superlight is good enough. And yet, the 236|artisan zero, the most unassuming of artisans 237| 238|48 239|00:04:03,760 --> 00:04:08,400 240|entire lineup, manages to be one of the best 241|mousepads I've used for such a wide variety of 242| 243|49 244|00:04:08,400 --> 00:04:13,960 245|purposes that there really is nothing like it 246|for me. If I had to use one mousepad forever, 247| 248|50 249|00:04:13,960 --> 00:04:18,280 250|this is what I'd choose. I don't think there is 251|a safer recommendation to give out of artisans 252| 253|51 254|00:04:18,280 --> 00:04:23,160 255|lineup with one caveat that I'll get to later. 256|If you don't want to think too much about which 257| 258|52 259|00:04:23,160 --> 00:04:27,960 260|artisan to get and just want something that can 261|do everything well, this is the way to go. 262| 263| 264|53 265|00:04:27,960 --> 00:04:33,040 266|In terms of friction it places here relative 267|to other artisans, but despite how the numbers 268| 269|54 270|00:04:33,040 --> 00:04:38,040 271|look it doesn't feel significantly more "muddy" 272|than something like the otsu to me. I think this 273| 274|55 275|00:04:38,040 --> 00:04:41,760 276|is because of the pad's static friction, 277|the force that keeps the mouse in place, 278| 279|56 280|00:04:41,760 --> 00:04:47,440 281|being only slightly slower than the otsu's. So 282|it's not that much harder to start movements, 283| 284|57 285|00:04:47,440 --> 00:04:51,840 286|but the extra resistance you feel when moving 287|the mouse, also known as the dynamic friction, 288| 289|58 290|00:04:51,840 --> 00:04:56,720 291|makes it easier to stop those movements as well as 292|providing a sort of "guiding force" that makes my 293| 294|59 295|00:04:56,720 --> 00:05:01,840 296|flicks feel cleaner directionally than they do 297|on faster artisans. This is what I think makes 298| 299|60 300|00:05:01,840 --> 00:05:07,000 301|it so viable for basically everything, in games 302|like cs or valorant the higher dynamic friction 303| 304|61 305|00:05:07,000 --> 00:05:11,400 306|will help keep flicks feeling locked in while 307|still allowing for fluid micraodjustments and 308| 309|62 310|00:05:11,400 --> 00:05:16,280 311|in games with a higher time to kill like apex 312|or the finals the dynamic friction isn't so 313| 314|63 315|00:05:16,280 --> 00:05:20,600 316|high that it's impossible to adjust your aim 317|when a target changes their trajectory. It 318| 319|64 320|00:05:20,600 --> 00:05:24,520 321|just works well for everything, which I think 322|the variety of games I've used as background 323| 324|65 325|00:05:24,520 --> 00:05:28,480 326|footage demonstrates pretty well. 327|Given that I don't think it'll come as a 328| 329|66 330|00:05:28,480 --> 00:05:33,960 331|surprise when I say that it's my main choice for 332|basically every fps game, overwatch, battlefield, 333| 334|67 335|00:05:33,960 --> 00:05:39,640 336|counter strike, aimtraining, apex and so on, it's 337|honestly rare for me not to choose this mousepad 338| 339|68 340|00:05:39,640 --> 00:05:44,480 341|if im going to play a game, but it does happen 342|sometimes. For the finals I used the shidenkai 343| 344|69 345|00:05:44,480 --> 00:05:48,480 346|primarily since I found the zero to be a bit 347|too slow for some situations in that game, 348| 349|70 350|00:05:48,480 --> 00:05:53,240 351|and in valorant I swap between this and 352|a couple other controlled pads. So, while 353| 354|71 355|00:05:53,240 --> 00:05:57,920 356|it's not flawless, even in the situations where I 357|prefer another mousepad, the zero still performs 358| 359|72 360|00:05:57,920 --> 00:06:03,040 361|great and won't hold you back from reaching a 362|high level. It excels in basically all areas 363| 364|73 365|00:06:03,040 --> 00:06:08,040 366|and that's why I recommend it so universally. 367|But back to that caveat I mentioned earlier, this 368| 369|74 370|00:06:08,040 --> 00:06:12,920 371|pad actually has a reputation for being somewhat 372|rough on the skin which kind of confused me, when 373| 374|75 375|00:06:12,920 --> 00:06:18,680 376|I first tried it I honestly felt it didn't have 377|enough texture. That was the black xsoft version, 378| 379|76 380|00:06:18,680 --> 00:06:22,840 381|and while it being in xsoft certainly played a 382|role there is actually a difference between the 383| 384|77 385|00:06:22,840 --> 00:06:27,840 386|two colours, with the orange being noticeably 387|more textured and slightly faster. I still 388| 389|78 390|00:06:27,840 --> 00:06:32,160 391|wouldn't call it rough personally, it's never 392|irritated my skin and if anything I prefer the bit 393| 394|79 395|00:06:32,160 --> 00:06:36,960 396|of extra texture along with the bonus speed. I've 397|found that the two almost balance each other out, 398| 399|80 400|00:06:36,960 --> 00:06:40,880 401|the surface provides more feedback when aiming 402|which creates this feeling of extra control 403| 404|81 405|00:06:40,880 --> 00:06:45,760 406|when compared to a perfectly smooth mousepad. 407|Regardless though, this is something to be aware 408| 409|82 410|00:06:45,760 --> 00:06:50,160 411|of - if you are looking for what I described 412|earlier go with the orange, it's my basically 413| 414|83 415|00:06:50,160 --> 00:06:55,040 416|universal recommendation and works well in every 417|game with every sens, but if you think you'd like 418| 419|84 420|00:06:55,040 --> 00:07:02,280 421|something slightly slower and smoother, like if 422|you mainly play tac fps games, then you can either 423| 424|85 425|00:07:02,280 --> 00:07:07,960 426|go with the black version of the zero or look 427|into artisan's proper control pad, the type99. 428| 429| 430|86 431|00:07:07,960 --> 00:07:11,840 432|I want to say right away though that this 433|mousepad isn't just a little bit slower than 434| 435|87 436|00:07:11,840 --> 00:07:17,280 437|the zero. This is a proper control pad right up 438|there with mousepads like the Zowie GSR but it 439| 440|88 441|00:07:17,280 --> 00:07:22,560 442|doesn't actually feel that slow? Don't get me 443|wrong though, it is still very slow and I feel 444| 445|89 446|00:07:22,560 --> 00:07:27,520 447|I get a fair bit of extra control and stopping 448|power when using it but unlike other slow pads 449| 450|90 451|00:07:27,520 --> 00:07:33,200 452|I wouldn't use the term "muddy" to describe it. To 453|me that implies a level of resistance to starting 454| 455|91 456|00:07:33,200 --> 00:07:38,240 457|movements that this pad just doesn't have. I'm 458|sure a part of it is how smooth the surface feels, 459| 460|92 461|00:07:38,240 --> 00:07:43,320 462|there's no tug and very little friction on my arm 463|which makes it seem faster than it actually is, 464| 465|93 466|00:07:43,320 --> 00:07:47,200 467|but I think the main cause of this 468|phenomenon is the friction balancing. 469| 470| 471|94 472|00:07:47,200 --> 00:07:51,480 473|The core idea here is the same as with the 474|zero, make the static friction relatively low 475| 476|95 477|00:07:51,480 --> 00:07:56,600 478|while keeping dynamic high, but when shifted to 479|a surface with more friction overall that effect 480| 481|96 482|00:07:56,600 --> 00:08:01,880 483|is even more visible. What this translates 484|to in game is that for smaller movements, 485| 486|97 487|00:08:01,880 --> 00:08:06,240 488|starting them will take more force than on 489|the zero for example, which could lead to 490| 491|98 492|00:08:06,240 --> 00:08:10,640 493|overadjustments if you aren't used to it, but most 494|of the time that extra force will be controlled 495| 496|99 497|00:08:10,640 --> 00:08:16,680 498|for by the dynamic friction, which works with you 499|to stop your mouse. This contributes to a feeling 500| 501|100 502|00:08:16,680 --> 00:08:22,080 503|of stability and control on microadjustments 504|but also works surprisingly well for wider and 505| 506|101 507|00:08:22,080 --> 00:08:27,920 508|faster flicks. I think a lot of people expect 509|a faster pad to improve their flicking speed, 510| 511|102 512|00:08:27,920 --> 00:08:32,480 513|but in my experience being able to work with 514|the friction of a mousepad actually helped me 515| 516|103 517|00:08:32,480 --> 00:08:37,640 518|flick more quickly. By removing the instability 519|at the end of flicks that's often present faster 520| 521|104 522|00:08:37,640 --> 00:08:43,040 523|mousepads, slower pads like the type99 help give 524|me the confidence to push my flicks faster than 525| 526|105 527|00:08:43,040 --> 00:08:47,760 528|I could on a speed pad, and that's on top of 529|the benefit of higher dynamic friction that 530| 531|106 532|00:08:47,760 --> 00:08:52,400 533|I talked about in relation to the zero, with 534|it almost acting as a guiding force that keeps 535| 536|107 537|00:08:52,400 --> 00:08:56,640 538|your flicks directionally consistent. 539|Because of that I think this pad works 540| 541|108 542|00:08:56,640 --> 00:09:02,360 543|exceptionally well for tac fps games like valorant 544|and cs2 or faster paced shooters like battlefield 545| 546|109 547|00:09:02,360 --> 00:09:07,640 548|or cod, that stability when microadjusting and 549|locked in feeling for flicking is hard to pass 550| 551|110 552|00:09:07,640 --> 00:09:12,480 553|up on and if games like that are all you play it's 554|probably one of the best from artisans lineup, but 555| 556|111 557|00:09:12,480 --> 00:09:17,720 558|I think this pad kind of falls apart when playing 559|a game that requires more varied aim than cs or 560| 561|112 562|00:09:17,720 --> 00:09:22,760 563|valorant. Which sounds kind of weird, if a game 564|is harder to aim in wouldn't we want the extra 565| 566|113 567|00:09:22,760 --> 00:09:28,720 568|control that the type99 offers? Not exactly, while 569|pads like this can help prevent some shakiness, 570| 571|114 572|00:09:28,720 --> 00:09:32,680 573|they do this through filtering out all small 574|movements through their high static friction, 575| 576|115 577|00:09:32,680 --> 00:09:37,720 578|including intentional ones. And while this won't 579|effect microadjustments in a game like valorant, 580| 581|116 582|00:09:37,720 --> 00:09:42,240 583|for very precise tracking you'll have to put more 584|effort in to have your physical mouse movements 585| 586|117 587|00:09:42,240 --> 00:09:47,440 588|replicated in game. Which, weirdly enough, 589|actually made my aim look more shaky in games like 590| 591|118 592|00:09:47,440 --> 00:09:53,720 593|the finals. In that game, while tracking people 594|moving in straight or predictable lines was ok, 595| 596|119 597|00:09:53,720 --> 00:09:57,480 598|it was really hard to keep up with targets 599|moving erratically and I'd much rather have 600| 601|120 602|00:09:57,480 --> 00:10:03,080 603|been using a faster pad. I felt similarly in apex 604|or overwatch too, where even the relatively small 605| 606|121 607|00:10:03,080 --> 00:10:08,600 608|bit of extra speed offered by the zero makes 609|a massive difference compared to the type99. I 610| 611|122 612|00:10:08,600 --> 00:10:12,520 613|also think saying it's good for flicks and 614|microadjustments doesn't really tell the 615| 616|123 617|00:10:12,520 --> 00:10:17,800 618|whole story, while the design philosophy behind 619|the surface does help with each individually, 620| 621|124 622|00:10:17,800 --> 00:10:22,880 623|when I had to go from making a flick to making 624|a microadjustment that locked in feeling turned 625| 626|125 627|00:10:22,880 --> 00:10:27,440 628|into a downside. I couldn't smoothly start one 629|movement right after ending another, I'd get 630| 631|126 632|00:10:27,440 --> 00:10:32,440 633|caught in the inertia of that previous movement 634|and couldn't continue before it had faded. 635| 636| 637|127 638|00:10:32,440 --> 00:10:37,560 639|Personally, I much prefer the zero but like I 640|said, this pad can still work and all of these 641| 642|128 643|00:10:37,560 --> 00:10:42,000 644|downsides are typically much worse on other 645|control pads thanks to them not having lower 646| 647|129 648|00:10:42,000 --> 00:10:47,520 649|relative static friction. The type99 is the 650|best at what it does, I just don't like what 651| 652|130 653|00:10:47,520 --> 00:10:51,240 654|it's trying to do that much for the games I 655|play and I don't feel like I need that extra 656| 657|131 658|00:10:51,240 --> 00:10:55,360 659|stability coming from from the zero, but it 660|still might a good option for you if you want 661| 662|132 663|00:10:55,360 --> 00:11:00,400 664|that stability on flicks and don't play games with 665|varied movement or just really like using slower 666| 667|133 668|00:11:00,400 --> 00:11:05,840 669|mousepads and want the best one you can get. 670|Then, what about a mousepad more suited to games 671| 672|134 673|00:11:05,840 --> 00:11:09,960 674|like that? Could something faster offer that 675|freedom of movement we are looking for? The 676| 677|135 678|00:11:09,960 --> 00:11:15,400 679|raiden is the fastest purely cloth mousepad I've 680|ever used and feels really distinct because of 681| 682|136 683|00:11:15,400 --> 00:11:20,840 684|that. I honestly struggle to describe how the 685|surface feels, since it's not smooth in the same 686| 687|137 688|00:11:20,840 --> 00:11:26,640 689|way other smooth pads are, it doesn't have a lack 690|of texture, it has a lack of abrasiveness within 691| 692|138 693|00:11:26,640 --> 00:11:33,880 694|that texture. It's almost like silky, and that 695|feeling carries over into the pad's glide. There 696| 697|139 698|00:11:33,880 --> 00:11:38,720 699|is very little resistance in terms of both dynamic 700|and static friction which means that starting and 701| 702|140 703|00:11:38,720 --> 00:11:44,120 704|continuing movements is effortless. Because of 705|that effortlessness, I find it very well suited 706| 707|141 708|00:11:44,120 --> 00:11:49,520 709|to particularly flowy and dynamic aiming styles, 710|which makes it stand out for three types of games 711| 712|142 713|00:11:49,520 --> 00:11:54,520 714|in my opinion. The first is games with higher 715|time to kill and gradual movement acceleration, 716| 717|143 718|00:11:54,520 --> 00:11:58,960 719|with apex being a good example. While the lower 720|friction doesn't really help me with aiming at 721| 722|144 723|00:11:58,960 --> 00:12:03,280 724|long strafes compared to a control pad, it makes 725|a big difference when trying to track someone 726| 727|145 728|00:12:03,280 --> 00:12:08,760 729|changing directions. On slower pads it can be hard 730|to follow up an adjustment with a smooth track, 731| 732|146 733|00:12:08,760 --> 00:12:13,000 734|since you need to apply so much force to start 735|that movement that it's a bit hard to then control 736| 737|147 738|00:12:13,000 --> 00:12:17,680 739|that inertia to transition into that smooth 740|follow through that we want afterwards. This 741| 742|148 743|00:12:17,680 --> 00:12:22,240 744|harsh adjustment also generates more motion blur 745|which can make visually following the target after 746| 747|149 748|00:12:22,240 --> 00:12:27,880 749|that adjustment harder. By reducing the difference 750|in force needed to start and continue movements 751| 752|150 753|00:12:27,880 --> 00:12:32,240 754|it's easier to retain control after a change in 755|direction as well as making more gradual speed 756| 757|151 758|00:12:32,240 --> 00:12:38,160 759|changes easier so it won't be as hard to track 760|your target visually. All of this is possible on 761| 762|152 763|00:12:38,160 --> 00:12:43,560 764|slower mousepads but I found that using something 765|like this made it easier to lean into that style, 766| 767|153 </file-view>

<file-view path="/tmp/youtube_summary/The best mousepads you can get - Artisan buyer's guide.en.srt" start_line="768" end_line="1467" total_lines="1886"> 768|00:12:43,560 --> 00:12:47,920 769|which in a game like apex helps a lot. 770|With that being said though, if you have 771| 772|154 773|00:12:47,920 --> 00:12:52,160 774|the mouse control to make those snappy 775|microadjustments without overcorrecting, 776| 777|155 778|00:12:52,160 --> 00:12:56,600 779|this pad works great too and is actually why I 780|recommend it for games with instant acceleration 781| 782|156 783|00:12:56,600 --> 00:13:02,320 784|like overwatch. For tracking faster strafes low 785|static friction is a massive bonus. Having as 786| 787|157 788|00:13:02,320 --> 00:13:07,040 789|little resistance as possible can almost make 790|it feel like you can react faster to movements 791| 792|158 793|00:13:07,040 --> 00:13:11,640 794|if you can control it. But I like to have 795|some dynamic friction to lean back on when 796| 797|159 798|00:13:11,640 --> 00:13:16,920 799|possible for tracking the movements in between 800|direction changes which this pad offers too. 801| 802|160 803|00:13:16,920 --> 00:13:22,480 804|It's not too fast that my clicking suffers either, 805|characters like cass are totally playable for me 806| 807|161 808|00:13:22,480 --> 00:13:27,480 809|on this pad whereas on something like the skypad 810|I actually felt a bit lacking in fine control. 811| 812| 813|162 814|00:13:27,480 --> 00:13:32,360 815|The third type of game I recommend this for 816|it actually... valorant and counter strike. 817| 818|163 819|00:13:32,360 --> 00:13:37,320 820|Which sounds odd, especially since I've already 821|talked at length about how nice more friction is 822| 823|164 824|00:13:37,320 --> 00:13:42,640 825|for those games due to the emphasis they place 826|on stability. For styles that focus on snappy 827| 828|165 829|00:13:42,640 --> 00:13:47,400 830|and clean microadjustments and place a lot of 831|emphasis on accurate preaim, that makes sense 832| 833|166 834|00:13:47,400 --> 00:13:52,640 835|and I do think slower pads are a safer option for 836|valorant, but if you consider what I said earlier 837| 838|167 839|00:13:52,640 --> 00:13:58,600 840|about flowy and dynamic styles in relation 841|to valorant, the raiden might start to make 842| 843|168 844|00:13:58,600 --> 00:14:03,960 845|a bit more sense. Some of the best aimers in that 846|game are amazing at chaining movements together, 847| 848|169 849|00:14:03,960 --> 00:14:08,720 850|smoothly blending one flick into a microadjustment 851|into another flick and having to fight the pad to 852| 853|170 854|00:14:08,720 --> 00:14:13,880 855|start each of those movements makes that style a 856|lot harder. That's why I think low static friction 857| 858|171 859|00:14:13,880 --> 00:14:18,920 860|can be a massive benefit if you aim like this, as 861|long as you have the control to make it work. 862| 863| 864|172 865|00:14:18,920 --> 00:14:23,600 866|Which I think is the first big potential caveat to 867|the raiden, you have to have the skill to utilise 868| 869|173 870|00:14:23,600 --> 00:14:28,840 871|it. Even though other surface types can be faster 872|this is still the fastest cloth pad I've tried and 873| 874|174 875|00:14:28,840 --> 00:14:32,640 876|I think people who haven't put as much time into 877|training their mouse control or struggle with 878| 879|175 880|00:14:32,640 --> 00:14:37,160 881|getting shaky under pressure might struggle to aim 882|well on it because of that. This'll be especially 883| 884|176 885|00:14:37,160 --> 00:14:41,440 886|true if you are looking for an upgrade from an 887|older control pad and in that case you might be 888| 889|177 890|00:14:41,440 --> 00:14:45,240 891|better off going with something like the zero 892|since it'll still be a lot faster than what 893| 894|178 895|00:14:45,240 --> 00:14:50,160 896|you have now. The other caveat is that I don't 897|think the durability is as good on this pad as 898| 899|179 900|00:14:50,160 --> 00:14:54,480 901|other artisans, the mid especially seems to wear 902|down as a rate much more in line with other cloth 903| 904|180 905|00:14:54,480 --> 00:14:59,520 906|pads and doesn't keep its crazy low friction for 907|as long as I'd like. I think it's a bit harder 908| 909|181 910|00:14:59,520 --> 00:15:05,200 911|to recommend compared to the zero or type99 but I 912|still really enjoy using it and if the experience 913| 914|182 915|00:15:05,200 --> 00:15:10,440 916|I described earlier sounds like something 917|you'd like it's still worth considering. 918| 919| 920|183 921|00:15:10,440 --> 00:15:14,240 922|Artisan does have a few other options for 923|people looking for a speed pad though, 924| 925|184 926|00:15:14,240 --> 00:15:19,080 927|all slightly toned down from the raiden but 928|all three of them offer, to varying degrees, 929| 930|185 931|00:15:19,080 --> 00:15:23,400 932|the benefits of low friction I talked about 933|earlier. The one you're probably most familiar 934| 935|186 936|00:15:23,400 --> 00:15:29,120 937|with is the hien. It was actually my first artisan 938|mousepad back in 2020, which makes sense since 939| 940|187 941|00:15:29,120 --> 00:15:34,160 942|it's probably the most well known artisan pad 943|and one of their most unique too, or at least 944| 945|188 946|00:15:34,160 --> 00:15:40,160 947|it used to be before everyone tried to clone it. I 948|think the hien more than stands up to those clones 949| 950|189 951|00:15:40,160 --> 00:15:45,520 952|though, even at it's higher price point and the 953|design philosophy behind it is still really solid. 954| 955|190 956|00:15:45,520 --> 00:15:50,280 957|It comes back to that point I made about the zero 958|and the benefits more surface texture can offer 959| 960|191 961|00:15:50,280 --> 00:15:56,200 962|and takes that idea to it's most extreme. This 963|pad is very rough and you'll feel that texture 964| 965|192 966|00:15:56,200 --> 00:16:01,400 967|both on your skin and through your mouse skates 968|and because of that it's a bit hard to adjust to, 969| 970|193 971|00:16:01,400 --> 00:16:06,760 972|but if you can get used to that texture it offers 973|a pretty incredible combination of traits. 974| 975| 976|194 977|00:16:06,760 --> 00:16:11,760 978|That benefit I mentioned earlier, how that 979|feedback from the pad can be a useful feature 980| 981|195 982|00:16:11,760 --> 00:16:16,720 983|when aiming, is on full effect here. There 984|is something I call flick consciousness, 985| 986|196 987|00:16:16,720 --> 00:16:21,280 988|which is just your ability to be aware of how far 989|you are moving your mouse mid flick, which if you 990| 991|197 992|00:16:21,280 --> 00:16:26,600 993|are very good at can lead to perfect transitions 994|between flicks and microadjustments. It has the 995| 996|198 997|00:16:26,600 --> 00:16:31,920 998|potential to completely remove the delay between 999|those two motions. That is something that was 1000| 1001|199 1002|00:16:31,920 --> 00:16:36,640 1003|way easier on this pad compared to the raiden 1004|especially actually, I felt much more aware of 1005| 1006|200 1007|00:16:36,640 --> 00:16:41,240 1008|where my flicks were going because of that instant 1009|feedback from the surface of the mousepad and it 1010| 1011|201 1012|00:16:41,240 --> 00:16:46,640 1013|translated really well into flicking scenarios in 1014|aimtrainers and similar situations in games. 1015| 1016| 1017|202 1018|00:16:46,640 --> 00:16:50,240 1019|But, even though transitioning between a 1020|flick and a microadjustment was easier, 1021| 1022|203 1023|00:16:50,240 --> 00:16:55,680 1024|my microadjustments themselves... they weren't 1025|great, they were noticeably worse than on other 1026| 1027|204 1028|00:16:55,680 --> 00:17:01,400 1029|artisans, even some faster ones. I think there 1030|are two reasons for this, and the first is the 1031| 1032|205 1033|00:17:01,400 --> 00:17:07,080 1034|friction balancing. Compared to most pads at this 1035|speed the hien has very low static friction which 1036| 1037|206 1038|00:17:07,080 --> 00:17:12,160 1039|can be nice, it promotes freedom of movement and 1040|makes motions easier to start, but that applies 1041| 1042|207 1043|00:17:12,160 --> 00:17:18,920 1044|for unintentional motions too. So shaky movements 1045|were really visible here. But the raiden xsoft has 1046| 1047|208 1048|00:17:18,920 --> 00:17:23,840 1049|very similar friction balancing and I don't have 1050|that issue there, so what makes the hien worse 1051| 1052|209 1053|00:17:23,840 --> 00:17:29,000 1054|in this regard? I think it is, once again, that 1055|surface texture. On something like the raiden 1056| 1057|210 1058|00:17:29,000 --> 00:17:33,760 1059|I can press my fingers against or into the pad 1060|slightly when making really fine movements which 1061| 1062|211 1063|00:17:33,760 --> 00:17:38,320 1064|almost acts like a brake, it gives you control 1065|over the amount of friction you experience based 1066| 1067|212 1068|00:17:38,320 --> 00:17:43,520 1069|on how far you press down. So, in a scenario like 1070|this one where I want a bit of static friction to 1071| 1072|213 1073|00:17:43,520 --> 00:17:48,760 1074|filter out jitters, I just press against the 1075|mousepad a little. On the hien that just gives 1076| 1077|214 1078|00:17:48,760 --> 00:17:54,240 1079|me friction burn. Yes, it is actually that rough, 1080|I've gotten skin irritations on my arm after using 1081| 1082|215 1083|00:17:54,240 --> 00:17:58,960 1084|this pad for extended periods of time before 1085|and that was on the xsoft version, which is the 1086| 1087|216 1088|00:17:58,960 --> 00:18:04,360 1089|least abrasive one. For me it basically rules out 1090|finger drag as a viable technique and I find it 1091| 1092|217 1093|00:18:04,360 --> 00:18:09,600 1094|pretty hard to use overall because of that, but I 1095|can still see why it's as well liked as it is. 1096| 1097| 1098|218 1099|00:18:09,600 --> 00:18:13,640 1100|If you have tougher skin than me and aren't 1101|as prone to irritation from abrasive surfaces 1102| 1103|219 1104|00:18:13,640 --> 00:18:17,880 1105|or don't utilise skin contact against the pad 1106|when aiming I can see it working pretty well for 1107| 1108|220 1109|00:18:17,880 --> 00:18:23,720 1110|microadjustments and fine tracking, and if you can 1111|use it the benefits for flicking are very visible. 1112| 1113|221 1114|00:18:23,720 --> 00:18:28,760 1115|I did still play pretty well on it, just not as 1116|well as other artisan pads and I don't enjoy using 1117| 1118|222 1119|00:18:28,760 --> 00:18:33,600 1120|it as much either. It's just not for me and is a 1121|bit hard to recommend especially when something 1122| 1123|223 1124|00:18:33,600 --> 00:18:38,840 1125|like the otsu offers a pretty similar aiming 1126|experience without as irritating of a surface. 1127| 1128| 1129|224 1130|00:18:38,840 --> 00:18:43,640 1131|And while that does act as a nice summary of 1132|the otsu, a less abrasive hien, and would be 1133| 1134|225 1135|00:18:43,640 --> 00:18:48,480 1136|a good selling point on it's own, I think that's 1137|missing out on some of the big factors as to why 1138| 1139|226 1140|00:18:48,480 --> 00:18:54,200 1141|so many people swear by this mousepad. The term 1142|"fast but controlled" has become so overused 1143| 1144|227 1145|00:18:54,200 --> 00:18:59,200 1146|in the peripheral space it honestly barely means 1147|anything anymore, but out of every mousepad I've 1148| 1149|228 1150|00:18:59,200 --> 00:19:05,040 1151|tried that's been given that description this is 1152|the only one where it actually fits. Objectively 1153| 1154|229 1155|00:19:05,040 --> 00:19:09,600 1156|it is very fast and you do get the benefits of 1157|that speed, but it doesn't really feel like a 1158| 1159|230 1160|00:19:09,600 --> 00:19:16,000 1161|speed pad when using it. So, how does it do it? 1162|And, do you actually want that from a mousepad? 1163| 1164| 1165|231 1166|00:19:16,000 --> 00:19:20,160 1167|I think there are three main factors, the 1168|first and most impactful is the relatively 1169| 1170|232 1171|00:19:20,160 --> 00:19:25,120 1172|high static friction. Even though it isn't 1173|that high compared to properly slow mousepads, 1174| 1175|233 1176|00:19:25,120 --> 00:19:29,800 1177|when putting it against the dynamic friction it 1178|is noticeably slower and what that translates to 1179| 1180|234 1181|00:19:29,800 --> 00:19:35,280 1182|is the pad filtering out more minor stutters and 1183|jitters which are usually present on faster pads, 1184| 1185|235 1186|00:19:35,280 --> 00:19:40,240 1187|especially when flicking quickly. This actually 1188|used to be my favourite mousepad mostly for this 1189| 1190|236 1191|00:19:40,240 --> 00:19:43,840 1192|reason, on something like the raiden when I'd 1193|try to flick fast there'd be a lot of shake at 1194| 1195|237 1196|00:19:43,840 --> 00:19:48,280 1197|the end of my movements but on this pad that 1198|was entirely gone, giving me the confidence to 1199| 1200|238 1201|00:19:48,280 --> 00:19:53,240 1202|flick faster than I usually would especially 1203|since the dynamic friction is still low. The 1204| 1205|239 1206|00:19:53,240 --> 00:19:58,200 1207|texture contributed to this confidence as well, 1208|it gave similar benefits to the hien in terms of 1209| 1210|240 1211|00:19:58,200 --> 00:20:01,880 1212|flick consciousness without being irritating 1213|on my skin at all and because of that lack 1214| 1215|241 1216|00:20:01,880 --> 00:20:06,040 1217|of irritation I could still glide my fingers 1218|against the pad and pushing them into the pad 1219| 1220|242 1221|00:20:06,040 --> 00:20:10,520 1222|had a massive effect on the static friction, 1223|increasing it further still relative to the 1224| 1225|243 1226|00:20:10,520 --> 00:20:16,320 1227|dynamic. All of that led to this mousepad being 1228|perfect for movements like this one, super fast 1229| 1230|244 1231|00:20:16,320 --> 00:20:21,360 1232|and snappy flicks with minimal shake after, and 1233|I loved it for that style and I think if you aim 1234| 1235|245 1236|00:20:21,360 --> 00:20:27,960 1237|in a similar way it's a great recommendation. 1238|But, that was way back in 2021, my style's changed 1239| 1240|246 1241|00:20:27,960 --> 00:20:33,000 1242|a lot since then and honestly I feel like I've 1243|kind of outgrown this mousepad, as strange as 1244| 1245|247 1246|00:20:33,000 --> 00:20:38,720 1247|that sounds. "Fast but controlled" is amazing 1248|in theory but isn't without it's downsides, and 1249| 1250|248 1251|00:20:38,720 --> 00:20:43,640 1252|here that really stood out to me in my fluidity 1253|and microadjustments. Because the difference 1254| 1255|249 1256|00:20:43,640 --> 00:20:48,680 1257|between static and dynamic friction was so high, 1258|especially when applying downwards pressure, going 1259| 1260|250 1261|00:20:48,680 --> 00:20:53,440 1262|between these two states felt very inconsistent. 1263|I'd have to apply so much force to get my mouse 1264| 1265|251 1266|00:20:53,440 --> 00:20:58,800 1267|moving that it would go way further than I wanted 1268|it to once it got over that threshold. The higher 1269| 1270|252 1271|00:20:58,800 --> 00:21:03,640 1272|resistance to starting movements also created 1273|a disconnect when chaining movements together, 1274| 1275|253 1276|00:21:03,640 --> 00:21:08,200 1277|it was very stop-start and, just to clarify, 1278|these things aren't always terrible, I made 1279| 1280|254 1281|00:21:08,200 --> 00:21:13,080 1282|them work back then. However, I feel like as I got 1283|better as a player and leaned more into fluidity 1284| 1285|255 1286|00:21:13,080 --> 00:21:18,400 1287|and controlled microadjustments that flick 1288|accuracy got less and less important and I felt 1289| 1290|256 1291|00:21:18,400 --> 00:21:23,720 1292|those downsides more and more. Especially since 1293|with better flicking technique I was able to get 1294| 1295|257 1296|00:21:23,720 --> 00:21:29,280 1297|similar flicks on something like the zero without 1298|needing to rely on having higher static friction 1299| 1300|258 1301|00:21:29,280 --> 00:21:34,080 1302|relative to the dynamic. I'm not trying to say 1303|that this pad is useless or anything either, just 1304| 1305|259 1306|00:21:34,080 --> 00:21:42,012 1307|that it works really well with a very specific 1308|style and as I stopped utilising that style 1309| 1310|260 1311|00:21:42,012 --> 00:21:43,680 1312|as much I gravitated towards pads that offered 1313|more balanced static and dynamic friction. 1314| 1315| 1316|261 1317|00:21:43,680 --> 00:21:49,000 1318|And for a long time, that was just the zero for 1319|me. While it was a touch slow for some things, 1320| 1321|262 1322|00:21:49,000 --> 00:21:53,720 1323|in the orange version it offered exactly what 1324|I wanted in terms of relative friction values. 1325| 1326|263 1327|00:21:53,720 --> 00:21:57,560 1328|Enough to aid a bit in stability but not 1329|too much to make chaining motions together 1330| 1331|264 1332|00:21:57,560 --> 00:22:02,040 1333|or microadjustments challenging. And honestly 1334|that might be more important to me than the 1335| 1336|265 1337|00:22:02,040 --> 00:22:06,400 1338|actual speed of a mousepad now, i feel like how 1339|well balanced the static and dynamic friction 1340| 1341|266 1342|00:22:06,400 --> 00:22:12,920 1343|is matters way more. Which I think is why 1344|I like artisan's newest release, the key83, 1345| 1346|267 1347|00:22:12,920 --> 00:22:17,880 1348|as much as I do. In terms of speed it sits 1349|very close to the otsu on the friction tests 1350| 1351|268 1352|00:22:17,880 --> 00:22:22,880 1353|I've done but really doesn't feel like it. 1354|Going by perception alone I'd place my soft 1355| 1356|269 1357|00:22:22,880 --> 00:22:27,680 1358|version in between the otsu and the zero, which 1359|I mostly put down to the texture but what also 1360| 1361|270 1362|00:22:27,680 --> 00:22:33,720 1363|plays a role and part of the reason I like this 1364|pad so much is it's consistency in every aspect. 1365| 1366|271 1367|00:22:33,720 --> 00:22:37,760 1368|Unlike the otsu, pressing down on it barely 1369|made it slower and didn't change the balance 1370| 1371|272 1372|00:22:37,760 --> 00:22:44,000 1373|of friction at all, so if I got nervous in a game 1374|or something I wouldn't have my pad turn into mud. 1375| 1376|273 1377|00:22:44,000 --> 00:22:48,760 1378|The most unique feature here though is actually 1379|the weave of the surface itself, most pads have 1380| 1381|274 1382|00:22:48,760 --> 00:22:53,440 1383|weaves containing threads that are longer in 1384|one direction, meaning that on every cloth pad 1385| 1386|275 1387|00:22:53,440 --> 00:22:58,760 1388|there will always be some difference between the 1389|speed when moving horizontally versus vertically. 1390| 1391|276 1392|00:22:58,760 --> 00:23:03,720 1393|On the key83 though, that weave is a hexagonal 1394|pattern, which while not exactly the same in 1395| 1396|277 1397|00:23:03,720 --> 00:23:08,840 1398|both directions, it actually feels a bit faster 1399|vertically for me, this is still far more uniform 1400| 1401|278 1402|00:23:08,840 --> 00:23:14,320 1403|than any other cloth pad I've tried. This doesn't 1404|translate into crazy game changing aim gains or 1405| 1406|279 1407|00:23:14,320 --> 00:23:18,400 1408|anything but I did feel a bit more confident 1409|going for diagonal flicks on this pad and it 1410| 1411|280 1412|00:23:18,400 --> 00:23:22,840 1413|felt great for vertical movements. It's harder 1414|for us to move the mouse vertically compared 1415| 1416|281 1417|00:23:22,840 --> 00:23:27,040 1418|to horizontally so it never made sense to 1419|me that basically all our mousepads were 1420| 1421|282 1422|00:23:27,040 --> 00:23:31,720 1423|slightly slower when moving in that direction, 1424|which just compounded on the already existing 1425| 1426|283 1427|00:23:31,720 --> 00:23:36,960 1428|difficulty. I did feel more confident making small 1429|vertical micros especially and this feature is a 1430| 1431|284 1432|00:23:36,960 --> 00:23:42,520 1433|nice bonus to an already great mousepad. 1434|I think the key word here is consistency, 1435| 1436|285 1437|00:23:42,520 --> 00:23:46,760 1438|out of every cloth pad I've tried this one has 1439|the least variance from day to day and movement 1440| 1441|286 1442|00:23:46,760 --> 00:23:52,000 1443|to movement and it being so minimally affected by 1444|downwards pressure lets me press my fingers onto 1445| 1446|287 1447|00:23:52,000 --> 00:23:57,280 1448|or into the pad for extra friction against my skin 1449|without it ruining the glide on my skates. That 1450| 1451|288 1452|00:23:57,280 --> 00:24:02,080 1453|plus the slightly faster speed is enough to put 1454|it in a different category from the zero for me, 1455| 1456|289 1457|00:24:02,080 --> 00:24:06,240 1458|they don't compete with each other but fill 1459|different roles for different situations or 1460| 1461|290 1462|00:24:06,240 --> 00:24:11,040 1463|different people. If you want something slightly 1464|faster than the zero but operating on similar 1465| 1466|291 1467|00:24:11,040 --> 00:24:16,440 </file-view>

<file-view path="/tmp/youtube_summary/The best mousepads you can get - Artisan buyer's guide.en.srt" start_line="1468" end_line="1886" total_lines="1886"> 1468|design principles, the key83 is a great option 1469|and I highly recommend it. The only caveat I 1470| 1471|292 1472|00:24:16,440 --> 00:24:21,160 1473|can think of is that while this pad won’t 1474|actively disadvantage you in tac fps games, 1475| 1476|293 1477|00:24:21,160 --> 00:24:25,720 1478|I personally would rather have something with a 1479|bit more control most of the time. This pad still 1480| 1481|294 1482|00:24:25,720 --> 00:24:30,520 1483|works in those games though and I prefer it to the 1484|otsu or hien, but yeah I think I would take the 1485| 1486|295 1487|00:24:30,520 --> 00:24:37,640 1488|zero over all three in cs2 just as an example. 1489|But I'd be missing something if I didn't talk 1490| 1491|296 1492|00:24:37,640 --> 00:24:43,280 1493|about the key83 mid specifically here, since when 1494|you take the properties of consistency across 1495| 1496|297 1497|00:24:43,280 --> 00:24:48,280 1498|all directions and levels of force, compound them 1499|through an even firmer base and increase the speed 1500| 1501|298 1502|00:24:48,280 --> 00:24:54,600 1503|significantly, you get the most glass-like cloth 1504|pad I've ever used. Pinguefy has been basically 1505| 1506|299 1507|00:24:54,600 --> 00:24:59,040 1508|stuck on glass for the last 2 years now and has 1509|been unable to use cloth because of the properties 1510| 1511|300 1512|00:24:59,040 --> 00:25:04,600 1513|of glass those cloth pads didn't have, but this 1514|was their thoughts after trying the key83: 1515| 1516| 1517|301 1518|00:25:04,600 --> 00:25:09,440 1519|It's actually everything I want out of a mousepad, 1520|as somebody who has spent so much time with glass 1521| 1522|302 1523|00:25:09,440 --> 00:25:15,600 1524|but was pining for a few benefits that cloth 1525|provides you. For me, the key83 is the perfect 1526| 1527|303 1528|00:25:15,600 --> 00:25:20,920 1529|middle ground between cloth and glass. I feel 1530|like I'm improving as I adapt my older skillset 1531| 1532|304 1533|00:25:20,920 --> 00:25:27,080 1534|to this surface, and I'm steadily learning 1535|to incorporate new ones into my style. 1536| 1537| 1538|305 1539|00:25:27,080 --> 00:25:31,120 1540|I haven't used the mid variant enough to talk 1541|about it in more detail here, but if that use 1542| 1543|306 1544|00:25:31,120 --> 00:25:35,840 1545|case sounds like something you'd want to try, I'd 1546|recommend giving their video a watch. However, 1547| 1548|307 1549|00:25:35,840 --> 00:25:41,200 1550|the key83 even in the mid variant, still isn't 1551|quite all the way there in terms of speed, it's 1552| 1553|308 1554|00:25:41,200 --> 00:25:46,600 1555|certainly not slow but it can't match the level of 1556|frictionlessness that a glass pads can offer 1:1, 1557| 1558|309 1559|00:25:47,200 --> 00:25:52,840 1560|but artisan does have something that can. One 1561|that, for me, almost mirrors pingu's experience 1562| 1563|310 1564|00:25:52,840 --> 00:25:58,080 1565|with the key83. It's like a glass pad but with 1566|the features I missed from cloth pads. 1567| 1568| 1569|311 1570|00:25:58,080 --> 00:26:03,520 1571|The shidenkai v2 is insanely fast, that's it's 1572|main defining characteristic and blows the raiden 1573| 1574|312 1575|00:26:03,520 --> 00:26:09,480 1576|out of the water in terms of pure speed. And yet 1577|what stuck out to me was the control offered here 1578| 1579|313 1580|00:26:09,480 --> 00:26:14,880 1581|that isn't present on conventional glass pads. I 1582|promise this isn't another "fast but controlled" 1583| 1584|314 1585|00:26:14,880 --> 00:26:20,360 1586|thing but first I need to clarify something, 1587|when most people talk about glass mousepads 1588| 1589|315 1590|00:26:20,360 --> 00:26:24,760 1591|they are referring to what amounts to solid 1592|slabs of glass, there might be some coating 1593| 1594|316 1595|00:26:24,760 --> 00:26:29,600 1596|on top and a silicone base on the back but the 1597|primary material used to make the pad is just 1598| 1599|317 1600|00:26:29,600 --> 00:26:36,320 1601|glass. The shidenkai differs by keeping artisan's 1602|conventional base design and using a glass infused 1603| 1604|318 1605|00:26:36,320 --> 00:26:41,520 1606|surface instead of glass exclusively. What this 1607|means is that you get levels of speed that can 1608| 1609|319 1610|00:26:41,520 --> 00:26:46,800 1611|match or even surpass fully glass mousepads while 1612|not having the downsides that come with them. 1613| 1614| 1615|320 1616|00:26:46,800 --> 00:26:51,280 1617|I talked a bit ago about how myself and others 1618|manipulate the friction our pad produces to fit 1619| 1620|321 1621|00:26:51,280 --> 00:26:54,720 1622|whatever aiming situation we are in and how 1623|the texture of the hien prevented me from 1624| 1625|322 1626|00:26:54,720 --> 00:26:59,720 1627|doing this there which led to me playing worse, 1628|but this downside applies to glass mousepads as 1629| 1630|323 1631|00:26:59,720 --> 00:27:05,120 1632|well. You can't press into them, they're solid 1633|glass, and dragging your fingers against the 1634| 1635|324 1636|00:27:05,120 --> 00:27:10,120 1637|surface just leads to them getting stuck to the 1638|surface most of the time. But on the shidenkai, 1639| 1640|325 1641|00:27:10,120 --> 00:27:14,200 1642|you can do both without ruining the balance 1643|between dynamic and static friction and with 1644| 1645|326 1646|00:27:14,200 --> 00:27:19,160 1647|very minimal skin sticking. And while some 1648|people like the consistency offered by glass 1649| 1650|327 1651|00:27:19,160 --> 00:27:23,800 1652|pads not letting you press into them, for me the 1653|ability to control the level of friction there is 1654| 1655|328 1656|00:27:23,800 --> 00:27:28,360 1657|is too valuable to give up, even if the glide 1658|might be a bit less consistent because of it. 1659| 1660|329 1661|00:27:28,360 --> 00:27:33,360 1662|It's so valuable that this benefit alone is enough 1663|to set it well above basically every glass pad 1664| 1665|330 1666|00:27:33,360 --> 00:27:38,200 1667|I've tried, it is just more versatile thanks to 1668|that varied friction and I find it way way easier 1669| 1670|331 1671|00:27:38,200 --> 00:27:43,520 1672|to aim on while still maintaining the benefits of 1673|a super low friction surface. Some kovaaks scores 1674| 1675|332 1676|00:27:43,520 --> 00:27:49,160 1677|I still haven't beaten to this day were set back 1678|when I was mainly using this pad in late 2023. 1679| 1680| 1681|333 1682|00:27:49,160 --> 00:27:54,520 1683|So, what are those benefits here? The main one 1684|for me is in games or aiming situations like 1685| 1686|334 1687|00:27:54,520 --> 00:28:00,200 1688|these ones: extremely evasive targets with varied 1689|movements, I find that on a higher friction pad, 1690| 1691|335 1692|00:28:00,200 --> 00:28:04,720 1693|say, the freefall sv base+ for example, 1694|maintaining control on those direction 1695| 1696|336 1697|00:28:04,720 --> 00:28:09,440 1698|changes is very challenging thanks to that side 1699|effect of static friction I talked about before. 1700| 1701|337 1702|00:28:09,440 --> 00:28:14,160 1703|The force needed to overcome that friction bleeds 1704|into future movements which leads to me tensing 1705| 1706|338 1707|00:28:14,160 --> 00:28:21,120 1708|the muscles in my arm to control for it. On pads 1709|this fast that static friction may as well not be 1710| 1711|339 1712|00:28:21,120 --> 00:28:25,880 1713|present meaning, and on the shidenkai specifically 1714|I can press down into the pad after the adjustment 1715| 1716|340 1717|00:28:25,880 --> 00:28:30,840 1718|if needed to get back that stability that a 1719|control pad would've offered. Flick stability 1720| 1721|341 1722|00:28:30,840 --> 00:28:35,800 1723|is much better than on other extremely fast 1724|mousepads too, that variable friction makes a 1725| 1726|342 1727|00:28:35,800 --> 00:28:39,800 1728|massive difference and leads to some actually 1729|pretty good stopping power considering how 1730| 1731|343 1732|00:28:39,800 --> 00:28:45,160 1733|low the base friction actually is. 1734|But, you can't get the shidenkai right 1735| 1736|344 1737|00:28:45,160 --> 00:28:50,240 1738|now. Artisan isn't producing it anymore due to 1739|some issues the pad had, primarily certain mice 1740| 1741|345 1742|00:28:50,240 --> 00:28:54,160 1743|like the g pro superlight having tracking 1744|issues but there were other concerns too, 1745| 1746|346 1747|00:28:54,160 --> 00:28:59,600 1748|namely with durability and dot skates not 1749|really working here at all, at least on the 1750| 1751|347 1752|00:28:59,600 --> 00:29:03,760 1753|xsoft version they just sink in so much that 1754|the base of the mouse scratches against the 1755| 1756|348 1757|00:29:03,760 --> 00:29:09,600 1758|mousepad. That idea of variable friction on a 1759|speed pad lives on to lesser extents though, 1760| 1761|349 1762|00:29:09,600 --> 00:29:15,880 1763|through pads like the fnatic jet, vancer ace or 1764|even the raiden from artisan themselves. I've also 1765| 1766|350 1767|00:29:15,880 --> 00:29:20,760 1768|heard the infinitymice speed referenced as fitting 1769|into this category but I haven't tried it myself 1770| 1771|351 1772|00:29:20,760 --> 00:29:25,240 1773|so I don't want to say anything definitive. As 1774|for artisan producing the shidenkai again in the 1775| 1776|352 1777|00:29:25,240 --> 00:29:28,760 1778|future, there was some conflicting info out there 1779|about a potential shidenkai v3 so I reached out 1780| 1781|353 1782|00:29:28,760 --> 00:29:33,280 1783|to artisan directly. I'm paraphrasing here but 1784|the full message is linked in the description 1785| 1786|354 1787|00:29:33,280 --> 00:29:38,800 1788|if you'd like to read it. "Firstly, they are 1789|working on a new speed focused mousepad. Second, 1790| 1791|355 1792|00:29:38,800 --> 00:29:43,720 1793|they have considered utilising non-cloth materials 1794|for the surface again like the shidenkai had, 1795| 1796|356 1797|00:29:43,720 --> 00:29:47,560 1798|but because they believe in the value their 1799|multi-firmness options offer they won't be 1800| 1801|357 1802|00:29:47,560 --> 00:29:52,280 1803|making a conventional solid glass mousepad, so 1804|you're not going to see a skypad competitor from 1805| 1806|358 1807|00:29:52,280 --> 00:29:57,400 1808|artisan. Third, they have no firm plans 1809|for a release date and it takes months to 1810| 1811|359 1812|00:29:57,400 --> 00:30:03,000 1813|years to develop, test and release a product of 1814|this nature." So, and this is me talking now, 1815| 1816|360 1817|00:30:03,000 --> 00:30:07,920 1818|if you don't mind waiting and the ideas I talked 1819|about relating to the shidenkai appeal to you, 1820| 1821|361 1822|00:30:07,920 --> 00:30:14,840 1823|this might be worth waiting for, but it might 1824|be a while before we see anything definitive. 1825| 1826| 1827|362 1828|00:30:14,840 --> 00:30:21,120 1829|And now for the question that could undermine this 1830|entire video: Are artisan mousepads actually worth 1831| 1832|363 1833|00:30:21,120 --> 00:30:26,240 1834|the money? For me, absolutely. I know the price 1835|looks a bit steep especially when buying from 1836| 1837|364 1838|00:30:26,240 --> 00:30:31,400 1839|resellers but when buying from artisan themselves 1840|it's honestly not that bad, doubly so when getting 1841| 1842|365 1843|00:30:31,400 --> 00:30:37,440 1844|two at a time to save on shipping, and you get 1845|the quality you pay for here. I personally find 1846| 1847|366 1848|00:30:37,440 --> 00:30:41,800 1849|mousepads more impactful than mice when it comes 1850|to how I aim and because of that I don't mind 1851| 1852|367 1853|00:30:41,800 --> 00:30:47,480 1854|spending a bit extra for the best I can get. But 1855|there are cheaper options out there that won't be 1856| 1857|368 1858|00:30:47,480 --> 00:30:52,520 1859|that much worse. If you've got the money to spend 1860|and any of these pads sounds appealing to you, 1861| 1862|369 1863|00:30:52,520 --> 00:30:56,360 1864|I don't think you'd regret buying them, but 1865|there's nothing wrong with choosing to opt for 1866| 1867|370 1868|00:30:56,360 --> 00:31:01,720 1869|something cheaper or more available instead. I 1870|don't go out of my way to try artisan clones so 1871| 1872|371 1873|00:31:01,720 --> 00:31:06,360 1874|I don't know of too many, but these are some good 1875|alternatives to some of the pads I've talked about 1876| 1877|372 1878|00:31:06,360 --> 00:31:10,680 1879|in the video. They won't be exactly what I've 1880|talked about here but hopefully they should feel 1881| 1882|373 1883|00:31:10,680 --> 00:31:27,920 1884|at least similar and I think they all offer pretty 1885|good value for money. Thanks for watching. </file-view>

Output from command in shell 58b8a1: WARNING: Your yt-dlp version (2025.12.08) is older than 90 days! It is strongly recommended to always use the latest version. You installed yt-dlp with pip or using the wheel from PyPi; Use that to update. To suppress this warning, add --no-update to your command/config. WARNING: [youtube] [jsc] Remote components challenge solver script (deno) and NPM package (deno) were skipped. These may be required to solve JS challenges. You can enable these downloads with --remote-components ejs:github (recommended) or --remote-components ejs:npm , respectively. For more information and alternatives, refer to https://github.com/yt-dlp/yt-dlp/wiki/EJS WARNING: [youtube] y7mCxC7033A: n challenge solving failed: Some formats may be missing. Ensure you have a supported JavaScript runtime and challenge solver script distribution installed. Review any warnings presented before this message. For more details, refer to https://github.com/yt-dlp/yt-dlp/wiki/EJS The best mousepads you can get - Artisan buyer's guide\nViscose\n31:46 Exit code: 0

The best mousepads you can get - Artisan buyer's guide by Viscose (31:46)

This is a detailed buyer's guide for Artisan gaming mousepads. The speaker argues Artisan pads are so widely recommended because they cover nearly every niche, from slow control pads to fast speed pads, while sharing excellent build quality.

Universal Artisan features

Stitching: sits below the pad surface so it doesn't catch your arm.
Durability: the speaker's Zero Softs last ~9 months before slowing, versus ~3 months for a Zowie G-SR-SE.
Base: very sticky, made from a different material than most pads.
Firmness options: each surface comes in XSoft, Soft, and Mid. Soft is the safest all-rounder. Mid resists unintentional downward pressure from nervous tension. XSoft is plush and good if you intentionally press into the pad, but hard to control and bad with small mouse skates.

Pad-by-pad breakdown

Zero — the safest universal pick. "If I had to use one mousepad forever, this is what I'd choose." It has slightly higher dynamic friction than static friction, making flicks feel directionally clean while still allowing microadjustments. Works for CS/Valorant, Apex, Overwatch, Battlefield, aim trainers. The orange version is a bit more textured and slightly faster (his main recommendation); black is smoother and slightly slower.

Type-99 — a true control pad, comparable to a Zowie GSR. Low static friction with high dynamic friction gives great stopping power and stability for tac FPS. Struggles in games with varied, erratic movement (Apex, The Finals, Overwatch) because the high friction makes chaining movements feel stop-start.

Raiden — the fastest purely cloth Artisan pad. Silky, low static and dynamic friction. Best for flowy/dynamic aiming: Apex tracking, Overwatch fast strafes, and even Valorant/CS for players who chain flicks and microadjustments smoothly. Requires good mouse control; durability is weaker than other Artisan pads.

Hien — very rough, texture-heavy surface. Gives strong "flick consciousness" (awareness of mouse movement mid-flick) but low static friction exposes shakiness. The abrasive texture can irritate skin and rules out finger drag. The speaker doesn't enjoy it but acknowledges it works for players with tough skin who don't drag.

Otsu — like a less abrasive Hien; "fast but controlled" actually fits here. High static friction relative to dynamic friction filters out jitters, making fast flicks feel stable. The speaker used to main it but outgrew it: the high static/dynamic gap makes chaining movements and fluid microadjustments feel inconsistent and stop-start.

Key83 — Artisan's newest release. Speed is close to the Otsu on paper but feels between Otsu and Zero. Extremely consistent regardless of downward pressure. Its hexagonal weave makes horizontal and vertical speed unusually uniform (slightly faster vertically), which helps with diagonal flicks and vertical microadjustments. The Mid variant is described as the "most glass-like cloth pad" and a good cloth/glass middle ground.

Shidenkai V2 — insanely fast, faster than the Raiden. Uses a glass-infused surface with Artisan's conventional foam base, so it reaches glass-pad speed while still allowing you to press down for variable friction and stability. Best for extremely evasive, erratic targets. Notably not currently in production due to sensor tracking issues (e.g. G Pro Superlight), durability concerns, and dot skates sinking into the XSoft version. Artisan told the speaker they are working on a new speed-focused pad and may use non-cloth surfaces again, but there is no release date.

Value verdict

The speaker thinks Artisan pads are worth the money, especially bought directly from Artisan (and in pairs to save shipping), because mousepads affect his aim more than mice. However, cheaper alternatives exist that aren't dramatically worse.