Mentions

@BaggyWorks @Axthurston Yeah it’s on my repo dude github.com/ashhart

I've been experimenting running inference over wifi between two of my devices over RPC (I'll soon move over to ethernet connection between my mac and homelab, but I'm able to jump from 64k -> 128k ctx doing this) Thanks @0xSero for your Ascii art repo 0xSero/ascii-art t.co

Pip 26.3 - Extended Pylock Support, Build Backend Warnings, and a caution on wheel installation Today I got to be the release manager for pip 26.3! There are two big features, and one documentation update, that I think worth talking about: Extended Pylock Support You can now install extras and non-default groups from a pylock file, e.g. pip install -r "pylock.toml[extra1,extra2]" and pip install --group pylock.toml:dev This supports the installation part of a workflow that generates a single lock file for multiple situations. For example, using a universal pylock file generator, such as a tool I built called nab, you might want to specify "I want a lock file with two mutually exclusive extras for different versions of SqlAlchemy and a dev dependency group", e.g.: [project.optional-dependencies] sa14 = ["sqlalchemy==1.4.*"] sa20 = ["sqlalchemy==2.0.*"] [dependency-groups] dev = ["pytest"] [tool.nab] conflicts = [[{ extra = "sa14" }, { extra = "sa20" }]] And now pip can pick which extra and group it wants to install from the output lock file, e.g. pip install --group 'pylock.toml[sa14]:dev' . This works with any tool that outputs standard pylock.toml files. Build backends warnings for local builds This one has been a long time coming, when you build a package from some kind of source, you invoke a build backend (e.g. setuptools, hatchling, flit-core, uv-build, poetry-core, etc.). That build backend can emit warnings to tell you something isn't configured correctly, or a feature will be dropped in the future. But for historical reasons, pip has never displayed those warnings (uv has inherited this and also doesn't display these warnings). Now, when building locally, e.g. pip install ., or pip install -e ., the build backend warning will be logged by default (and for non-local builds it will be in the -vv output). For example, if in setuptools you specify a README.mdfile but setuptools can't find it, you will get the warning: $ pip install . ... .../setuptools/config/expand.py:128: BuildBackendWarning: File '.../README.md' cannot be found A caution on installing untrusted wheels There have been a lot of supply chain attacks recently, and this has led to a lot of people learning about source distributions (sdists) which are built from source and can run arbitrary code on installation, as well as .pth files which after being installed run at the beginning of every Python execution. This has led a lot people to turn to only using binary distributions (with pip --only-binary :all: or slightly weaker --prefer-binary), otherwise known as wheels. What is great about wheels is they are just glorified zip files, and they are installed by unzipping the different parts of the wheel into the different Python installation locations. However, a word of caution, Python's import system is dynamic, and the moment a Python file exists in a location that can be imported, it can be imported even in a running Python processes. So while pip 26.3 includes significant hardening against untrusted wheels, we cannot guarantee installing a malicious wheel won't execute third party code. I can't speak for other tools, but I am fairly confident this applies to all other Python package installers (even those written in other languages). I will continue to do more hardening in pip where issues come up, and propose fixes in Python to improve the situation there. (Also, a possible future is lock files only first, where the locker refuses to install anything and refuses to execute third party code by default, then exact distributions can be validated/inspected before install, that's part of my pitch for nab which does the first step). Official Links The official announcement post is at: discuss.python.org The full change log: pip.pypa.io

Just published Agent Arithmetic agentzeta/agent-arithmetic (in continuation of my work on trusting AI agents and AI safety) medium.com

你在 Claude Code 里纠正过一次错，换个 Codex 窗口，它又犯。 开源记忆层 Beacon 能记下这次纠正，按你定的规则存成共享记忆，另一个 Agent 也能读到。 开源仓库：Asymptote-Labs/agent-beacon 按项目介绍，支持 Claude Code、Codex、Cursor、OpenCode 等 20 多个 Agent 运行框架。 原帖作者的四步，可以直接照着跑： 1、给 Claude Code 一个编程任务，它改代码、跑测试，Beacon 在后台录下整个过程。 2、让 Jev（做判断的模型）评审这次运行。第一次返回“需要复核”，因为他还没给正确改法，他的应用按规则什么都没存。 3、他手动纠正 Agent，Agent 改完重跑测试。Jev 再评审，这次符合应用的存储规则。 4、把纠正和证据存成共享记忆。另开一个 Codex 会话，明确让它读这条记忆，Codex 直接想起来了，不用重新解释。 分工要看清楚：Beacon 负责记录，Jev 负责判断什么值得留，你的应用负责定规则、决定存不存。不是让模型自己乱记。 价值也不在“记忆”两个字，在跨工具。你在一个 Agent 里踩过的坑，能带到另一个 Agent。 同一支视频里还讲了：会话在 Agent 之间迁移、把经验做成可复用技能、从 Agent 的操作记录里发现安全风险。作者是 Asymptote Labs 联合创始人 Justin。

Claude Code 2.1.317 更新，3 个日常用得到的： 1. 工具要把你的账号邮箱发到网络前，会先问你 2. 输入框按 Ctrl+C 清文字，不再顺手停掉所有后台 agent 3. 修了 claude auth status 可能害你下次被登出 升级 claude update，日志：github.com/anthropics/claude-code/blob/main/CHANG…

Kimi K3.1 Pro: 5,315 multilingual test results --- title: "Kimi K3.1 Pro: 5,315 multilingual test results" published: true description: "We ran 5,315 Japanese, German and Turkish tasks on Kimi K3.1 Pro. See the scores, charts, misses, evidence downloads and what they mean for business AI." tags: ai, llm, multilingual, benchmarks canonical_url: wallabytoken.com cover_image: wallabytoken.com --- Kimi K3.1 Pro scored 90.9% on Japanese idioms and 99.5% on Turkish paraphrase selection. We ran 5,315 source-dataset entries across Japanese, German and Turkish to see where those strengths hold, what they do not prove, and why the difference matters for business AI. German conversational meaning reached 87.7%. Turkish figurative-versus-literal usage reached 99.0%. The complete run returned 1,551,208 tokens and cost an estimated $6.169655 at list price, with every response, prediction and score preserved for review. !Kimi K3.1 Pro multilingual evaluation: 5,315 entries, with Japanese OpenMWE at 90.9%, German MultiPragEval at 87.7% and Turkish paraphrase selection at 99.5% Disclosure: Wallaby builds open-weight inference infrastructure. We ran this evaluation on Moonshot's official API on 2 November 2026. It is not a Wallaby production benchmark or a customer result. The numbers worth talking about Japanese OpenMWE asks whether a marked phrase is an idiom or literal language. Kimi K3.1 Pro answered 270 of 297 cases correctly. German MultiPragEval tests conversational meaning. The model answered 263 of 300 cases correctly. The two Turkish idiom tasks were stronger still: 199 of 200 on paraphrase selection and 195 of 197 on figurative-versus-literal usage. !Accuracy for six objective tasks: German MultiPragEval 87.7%, German InQA+ 66.7%, Japanese OpenMWE 90.9%, Turkish ImplicaTR 56.0%, Turkish paraphrase selection 99.5%, Turkish figurative versus literal usage 99.0% Those are useful results for teams building terminology checks, document classification and local-language workflows. They are also deliberately specific. Each percentage belongs to a named dataset, not to an entire language. What 5,315 entries actually include The full set covers public conversational, idiom and workplace tasks, plus nine small custom tasks for structured extraction and context reversal. !Evaluation coverage by language: German 687 entries, Japanese 340 entries and Turkish 4,288 entries | Dataset | Entries | What it measures | |---|---:|---| | German MultiPragEval | 300 | Conversational meaning | | German InQA+ | 384 | Indirect answers | | Japanese OpenMWE | 297 | Idiom versus literal meaning | | Japanese JaSocial | 10 | Public speech-act samples | | Japanese JWCAS | 30 | Open workplace scenarios | | Turkish ImplicaTR | 3,888 | Conversational implication | | Turkish Idioms | 397 | Paraphrase and figurative usage | | Custom tasks in three languages | 9 | Extraction and context reversal | | Total | 5,315 | — | Turkish makes up 80.7% of the entries because ImplicaTR alone contributes 3,888. That is why we do not average the six task scores into a single multilingual number. A large test set should not hide which tasks dominate it. <details> <summary>How we counted responses and prompts</summary> The 5,315 source-dataset entries contain 5,311 unique prompts. Four repeated prompts remain separate source-dataset rows. The 60 InQA+ supplement samples are part of the 384-entry InQA+ set, not an extra 60. We recorded 5,368 successful API responses in total. The difference comes from earlier duplicate sampling. Duplicate responses count toward execution cost, not toward the scored total. Every recorded response returned HTTP 200 and passed a content-hash check. </details> The more useful finding sits between the high scores Turkish idiom selection reached 99.5% and 99.0%. Turkish ImplicaTR scored 2,179 of 3,888, or 56.0%. German conversational meaning reached 87.7%. German InQA+ scored 256 of 384, or 66.7%. The label breakdown is more informative than the average: !German InQA+ accuracy by label: label 1 at 73.3%, label 2 at 73.3%, label 3 at 46.7%, label 4 at 85.5%, label 5 at 22.2% and label 6 at 0.0% Label 4, the non-answer category, reached 85.5%. Label 6, insufficient context, reached 0 of 22. A team using the model to decide when a conversation lacks enough information should keep an explicit review step for that decision. The same caution applies to Japanese workplace writing. We generated 30 JWCAS open-ended responses, but they still need native-speaker review. JaSocial covered 10 public samples with keyword-based function checks, not a naturalness score. We did not turn either one into a made-up accuracy number. What this means for local-language products Japanese: idiom and literal-meaning classification is a promising fit for structured document workflows. Open-ended business writing needs a separate native review process. German: conversational-meaning tasks are useful, but indirect answers and missing-context decisions need task-specific tests and escalation rules. Turkish: terminology and idiom workflows show strong results. Open-ended implication should be evaluated on representative customer text rather than inferred from idiom accuracy. For a product team, the practical question is not “Is this model multilingual?” It is “Does it work on this document, in this language, under these rules?” That is the evaluation we would run before choosing a model for a customer workflow. What the evaluation cost The run returned 1,551,208 tokens. Our list-price estimate is $6.169655, including duplicate sampling and different execution modes. | Execution stage | Estimated cost | |---|---:| | Initial 4,207 entries | $4.701157 | | Supplementary 90 entries | $0.348890 | | Professional-set direct calls | $1.119608 | | Total | $6.169655 | The first 1,000 Batch calls were estimated at 60% of standard price; the other stages used standard list rates. This is an evaluation-cost estimate, not an invoice, and it excludes taxes and any separate cache-write charges. Evidence and sources Download the evaluation artifacts: - Per-item results CSV - Summary JSON - Cost breakdown JSON - Evidence manifest Public datasets: MultiPragEval, Multilingual-IQA, OpenMWE, ImplicaTR, Turkish Idioms, JaSocial, JWCAS. We used kimi-k3.1-pro with low reasoning effort and the same output-format requirements within each task. Objective answers were scored against their labels; open-ended generations were left unscored. We did not run a same-prompt, same-condition Claude comparison, so this article makes no Kimi–Claude superiority claim. Try your own local-language workflow Wallaby provides OpenAI-compatible access to curated open-weight models, itemized usage billing and automatic provider failover. Kimi K3 is live on Wallaby today; the K3.1 Pro evaluation above does not imply that K3.1 Pro is available on Wallaby. New accounts receive $0.50 in free credit, with no card required until top-up. You can start your first API call, compare it with your own documents and see every token itemized. Self-serve top-ups start at $20. For the commercial details, see the current Kimi K3 pricing and our broader open-weight API pricing comparison. If you are estimating a longer evaluation, our agent context cost audit shows how repeated context changes the bill.

GitHub Actions lockfile がうれしいことは直ちに理解できて導入したけど、これにどう dependabot/renovate が PR 出してくるかというと、なるほどこうなる。そして複数のアプデが単一 lockfile に集中するので、lockfile でコンフリクトしやすいのは仕方ないな kindle-to-booklog#77

@tadeodonegana I made this tool and find it delightfully valuable ez-gz/shepherd It probably could use a UI/UX update (maybe I'll push my fork) but honestly $5 in 6.1-sol credits will get it to whatever form you want. It's just a more agent native tmux-mux

Location: Ulaanbaatar, Mongolia (UTC+8) Remote: Yes, remote only Willing to relocate: No Technologies: TypeScript, JavaScript, Python, React, Next.js, Ember.js, Node.js, NestJS, FastAPI, PostgreSQL, Docker; LLM integration, RAG, tool calling, agent systems Email: temuulen.developer@gmail.com GitHub: github.com/TemuulenBM I'm a full-stack engineer focused on applied AI. At GrapeCity Mongolia, I independently built internal infrastructure-management and AI-assisted DevOps tools. Previously, I worked at Fleetbase, contributing to its open-source logistics platform. My projects include AI assistants with RAG and tool calling, a multi-agent workspace, and customer-support software. I enjoy owning features end to end, from backend APIs and integrations to the user interface. I use AI coding agents extensively in my development workflow and am particularly interested in teams building useful AI products, agent systems, and internal automation. Open to full-time, part-time, and contract roles. I work well asynchronously and would be happy to discuss the project and expectations by email.

mcp-spreadsheet 能让 AI 按销售员汇总表格、给 CSV 加计算列，MIT 开源。 改现成 Excel 要小心：官方说明，写入的那张工作表会从数值重建，公式、格式和图表不保留。先另存副本，别让一次改表把模板也改没了。 zovo-one/mcp-spreadsheet

Completed HW6 of #MLZoomcamp by @DataTalksClub & @Al_Grigor! 🌳 • Tuned Random Forest depth & tree count • XGBoost eta=0.1: 1.725 validation RMSE • Documented results & environment versions c-ibarra/machine-learning-zoomcamp-homework #MachineLearning #DataScience

My Scribe v2 subtitle workflow: full-recording FLAC, native word timing and manual review I've been using ElevenLabs Scribe v2 as the transcription stage of a subtitle workflow, with Turkish-to-English and Ukrainian-to-English film testing. I'm a former professional translator/subtitler/interpreter and the developer of the open-source implementation, Subtitle Foundry. Here is how the Scribe path is set up: 1. Prepare one continuous 16 kHz mono FLAC. In the default full-recording mode, I retain music and silence rather than cutting the recording into speech-only segments. Optional short chunks are a separate processing choice. 2. Use Scribe's native word timestamps. This route doesn't run a second local speech-detection/alignment model. I keep the original response so the words and timing evidence remain inspectable. 3. Build cues from actual words and speaker turns. Speaker changes help split the subtitles. Anonymous speaker labels remain labels; the pipeline doesn't claim to identify the people speaking. 4. Flag timing problems for review. Timestamp anomalies and unusually long cues need inspection. I don't want postprocessing to hide a timing issue just because the exported file looks tidy. 5. Keep transcription separate from translation. The downstream translation uses dialogue context, while retaining source timing evidence. There is also an exact-timing mode for existing cues. A fluent translation still needs checking against what was said. 6. Finish with playback and waveform review. Wording and timing corrections are saved, and the result exports to SRT or ASS. Manual edits don't trigger another Scribe request; matching saved responses can be reused when resuming work. I haven't published a controlled provider comparison. These are the settings and implementation choices behind my current workflow, rather than a claim that the same configuration wins on every recording. Implementation and setup documentation: mrtdlgc/subtitle-foundry I'm not making money from this AGPL-3.0 project, and I'll keep maintaining it. The purpose is to bring state-of-the-art (SOTA) tools into a reviewable subtitle workflow for material that would otherwise fail to reach a global audience. Provider usage costs remain separate from the free app. I used Codex while building it and preparing this write-up.

密码管理器按人头收费，手机一个库电脑再买一次，换设备还得重登。 Keyguard 开源版，安卓+桌面用通用加密格式共用一个库，带生成器/强度检查/自动填充。 achep/keyguard-app

Oh nice, theres a way to run nixos on dgx sparks now. nixos has been my daily driver for over a year now so I'm excited to get it off crusty ubuntu asap graham33/nixos-dgx-spark

NIH, an exploration of what D&D 5e could have been I've finally gotten my rewrite/fork of the D&D 5e SRD to the point where I can make it public. homebrew.admiralbenbo.com (web version, hyperlinked HTML/CSS). github.com/bentomhall/nih-system/releases/tag/1.0… (zip file with the same content in pdf format) Note: both also contain some of the content (and some new content) ported to 5e directly. It's easier to keep them together. Second note: I flaired this as Feedback Request, but really I'm just putting this out. Comments are welcome, as are Pull Requests or Issues on the linked github repo. I may not incorporate suggestions, but I will consider them and respond. AI use: only to write scripts to do formatting and toolchain. All content is mine. --------- What is NIH? The name stands for Not Invented Here as well as Naming Is Hard; it's a meta joke that I couldn't come up with a better name. Suggestions welcome. Copied from the introduction: This game is designed to explore “paths not taken” for the venerable TTRPG it originally stems from. A love letter from a long-term fan. What might it look like if the historical constraints (some may say sacred cows; others may say legacy) were relaxed? If, instead of only lightly adhering to design principles like bounded accuracy and such, it bought in fully? If it made no pretense at being a generic game and instead focused on what it does best (that is, small-unit fantasy adventures in the heroic mode)? This is my attempt at exploring that space. NIH has been designed around my long-running campaign world, Dawn of Hope and its primary planet, Quartus. It should be relatively easily ported to other settings, although some of the content (cultures, deities, and backgrounds especially) will have to change. The core aesthetic and intended genre is “fantasy mercenary special forces adventures”. Your characters are set apart from the norm, but aren’t demigods or anything like that. You go places, make allies and enemies, fight (or sneak or talk) your way through situations and scenarios including (but not limited to) ancient ruins, crime-ridden cities, banquets of the rich and powerful, and exotic extra-planar locales. You grow stronger, but logarithmically. Fast at first, then slowing down. Often horizontally rather than vertically (gaining tools to approach different situations rather than simply getting bigger numbers). Gear provides benefits, but isn’t necessary nor is it the major source of your power. Generally, you will always be the underdogs against the movers and shakers, winning by teamwork, guile, skill, luck, and allies rather than brute force. The world is full of monsters (many of them in very familiar guises) and needs heroes. It’s not designed as a generic fantasy simulator, allowing players to build whatever characters they want out of bits and pieces. It’s designed for the players to lean into the archetypes and class fictions presented, or for GMs to design new archetypes for players. There is no multi-classing or “feats” as such. Instead there are many ways of getting access to abilities along parallel tracks, including but not limited to incantations (ritual utility magic available to anyone regardless of spell-casting ability) and skill tricks (effectively micro-feats you gain alongside your ability score increases or via features, some of which provide supernatural effects). It’s also not OSR (by any real meaning of that term). Nor is it designed for pure dungeon-crawling or procedurally-generated sandboxes, although it’s well-suited for non-linear play. It’s also not a “narrative game”. It comes down firmly on the side where players interact with the world via their characters rather than meta-currency or directly interacting with story elements. Nor is a pure tactical game. It’s basically a modern D&D clone. For better or worse. Yes, fundamentally this is the same core resolution mechanic and skeleton as 5th Edition D&D. And a lot of the content carries over (or can be easily translated). I make no attempt to hide that fact. Because, for me, that game does much of what I want. And it’s a game I continue to run every week. I’ve made an attempt to explain confusing or partially-described rules more to fit how I think about them and I’ve re-arranged the presentation to try to make things more clear. But it’s not some original creation, either as a system or a setting. ------- What has changed? A lot, actually. homebrew.admiralbenbo.com goes into (more detail). ------- What now? I don't really know. I doubt I'll ever get enough play-testers to do more polishing; art is too expensive for me to do, and I have no designs on actually publishing-for-profit. In fact, it's all licensed CC-BY-4.0 (except for a couple things modified from some 3rd party OGL material which is OGL-licensed). So anyone that finds it interesting is more than free to rip off the pieces they find interesting (with proper attribution of course).

Open-source this project to help you locate Supercharger sites in the US if you want to build or invest in a new one. @Tesla #supercharger #tesla CPTM511/supercharger-atlas

Modular subtitle transcription, translation and waveform review - Subtitle Foundry (AGPL-3.0)

[Free Release] AmpEQ - real headphone amp gain (no digital boost), system-wide 12-band EQ + 8,853 AutoEq presets for the iPod touch 7 (iOS 15, rootless) AmpEQ turns the iPod touch 7 into a proper music player. It runs inside iOS's audio service, so it works on everything the iPod plays. • Gain - turns up the iPod's own headphone amp past Apple's limit. No digital boost. Measured with a loopback recording: 0.50 dB steps, 0.001-0.003% distortion, clean up to +11 dB. Wired headphones only. • 12-band EQ - live curve, presets, imports AutoEq / Equalizer APO files • Headphone database - 8,853 AutoEq corrections, search your model and tap Apply • Peace-style clip meter + Prevent clipping (it knows the amp's real limit) • Plugins - DRX Dynamics, gxFeed, Crossfeed, Sound field, Pitch 432, Convolution, Balance • Volume steps - 16 to 100 button steps + optional step number in the status bar Compatibility: iPod touch 7 only · iOS 15.0-15.8.8 (tested on 15.8.6) · any rootless jailbreak (Dopamine or palera1n rootless). Repo: devincorumisok.github.io Source: devincorumisok/AmpEQ Free and open source (MIT). Feedback and bug reports welcome.

VPNゲートウェイ用のOS「Kozane」を開発している。ランサムウェアの侵入口として最も多いVPN機器（警察庁統計）を、壊れにくくするためのOS。 区画分離、耐量子暗号の必須化、外部入力を読む部分の数学的証明などを実装済み。まだ研究段階で、実業務には使えない。 ngc-shj/kozane

Accurate Audio Transcription API for Python Node.js Support Whisper for Control rev.ai for Speed Short answer: choose Whisper when a customer-support product can operate its own transcription service and needs the audio to stay inside its infrastructure. Choose rev.ai when a hosted API and broad language coverage matter more than operating another service. In either case, put the provider behind an application-owned transcript contract before using the text to answer questions from a private knowledge base. That boundary decides whether changing providers is a controlled migration or a rewrite. The support application should own the transcript version, ticket identity, timestamps, and answer schema. It should not let a vendor response shape the retrieval code. There is one important platform distinction. Infrai's /v1/audio/transcriptions route exists in the documented shape, but the capability is currently unavailable for service, so it is not the right transcription target for this workflow. Infrai can still be a reasonable downstream option after an ASR provider has been selected: one key and one bill across backend services removes the pile of credentials and invoices that otherwise grows around audio storage, retrieval, and answer generation. Its public discovery surface is self-describing and requires no key, which gives a migration-minded team a way to inspect request and response schemas before coupling an adapter to a ready capability. What is the bill actually made of? The visible transcription charge is only one part of this system. The larger operational question is how many audio minutes enter the pipeline, how often they are retried, and how long the raw recordings remain available. Retrieval and structured answer generation add work, but duplicate uploads and repeated transcription attempts can quietly dominate a support workflow. The failure mode is boring and expensive. Keep the handoff boring. A practical review records 4 quantities per ticket: source duration, transcription attempts, retained recording versions, and the transcript version used for retrieval. That makes a change in the dominant term visible. If the same recording is submitted twice because a worker timed out before recording the provider result, the system has a reliability problem as well as a billing event. Retention is the uncomfortable trade-off. Keep the raw recording for the period required by consent, dispute handling, and support policy. Keep a normalized transcript when it is sufficient for search and review. Do not copy sensitive audio into every component that can consume text. Deleting the source also deletes evidence. When a customer disputes a phrase, the recording can establish whether the transcript changed the meaning of a product name, ticket number, or delivery address. The policy therefore needs an owner, an expiration rule, and a record of which transcript version produced the answer. Storage cleanup is not the same thing as audit design. Which accurate audio transcription API should Python and Node.js SaaS teams choose? Whisper is an open-source model family that can be integrated into infrastructure the team operates. That gives the team control over the data boundary and deployment choices, while adding server setup, capacity planning, model operations, and observability to the product's responsibilities. It fits a support organization that treats sensitive audio handling as a reason to own the service. rev.ai is a hosted transcription service with an easy-to-use API and good language coverage. It shortens the route from an uploaded recording to a transcript, but the team must review the provider's data handling, contract, supported languages, and failure behavior. The hosted boundary is often the sensible choice when the product team wants to own ticket workflows rather than ASR operations. Two more hosted candidates deserve a fair test. AssemblyAI and Deepgram are real alternatives, with their own language, batch or streaming behavior, response fields, and operational contracts. OpenAI is a relevant adjacent option for teams that already use its API conventions, while Anthropic and Gemini are alternatives for the structured answer after transcription rather than evidence that a particular ASR choice is best. Those downstream models still need the same retrieved-evidence and schema checks. I would not call any of these universally most accurate without a representative corpus. “Accurate” is not one measurement in customer support: a transcript that misses a model number can retrieve the wrong article even when most words look correct. | Option | Control boundary | Main burden | Good fit | | --- | --- | --- | --- | | Whisper | Infrastructure operated by the team | Serving, capacity, and model setup | Sensitive audio and an operations team willing to own ASR | | rev.ai | Hosted transcription service | Provider contract and external-data review | Fast integration and broad language coverage | | AssemblyAI | Hosted transcription service | Feature-specific testing and provider dependency | A corpus that matches its supported workflow | | Deepgram | Hosted transcription service | Provider contract plus batch or streaming state | Teams evaluating its interaction model for support audio | Build the test set from actual support conditions: accents, background noise, product names, ticket identifiers, and short phrases that agents mishear. Score word-level errors, but also score whether the retrieved private article and structured answer are correct. The second score is closer to the product outcome. How do you keep the migration reversible? Treat ASR as an ingress adapter. The next stage consumes a Transcript, never a rev.ai payload or a Whisper-specific object. Provider name, request identifier, model metadata when available, and timestamps belong beside the stable fields rather than inside retrieval logic. Here is a deliberately small downstream call. It uses the OpenAI-compatible surface after ASR, asks for a structured support answer, reads the key from the environment, and does not treat a failed response as a successful answer. import json import os import time import requests def request_support_answer(ticket_id: str, transcript: str, evidence: list[str]) -> dict: api_key = os.environ["INFRAI_API_KEY"] body = { "model": "auto", "messages": [ { "role": "user", "content": json.dumps({ "ticket_id": ticket_id, "transcript": transcript, "evidence": evidence, }), } ], "response_format": { "type": "json_schema", "json_schema": { "name": "support_answer", "strict": True, "schema": { "type": "object", "properties": { "answer": {"type": "string"}, "article_ids": {"type": "array", "items": {"type": "string"}}, }, "required": ["answer", "article_ids"], "additionalProperties": False, }, }, }, } for attempt in range(4): response = requests.post( url="https://api.infrai.cc/v1/chat/completions", headers={"Authorization": f"Bearer {api_key}"}, json=body, timeout=30, ) if response.status_code == 429: retry_after = int(response.headers.get("Retry-After", "2")) time.sleep(retry_after * (2**attempt)) continue if not response.ok: raise RuntimeError(f"Infrai request failed: {response.status_code} {response.text}") return response.json() raise RuntimeError("Infrai request stayed rate-limited after 4 attempts") The ASR adapter should reject an empty transcript and malformed segments before indexing. It should also preserve the audio-object version and an application-owned job key. A retry after a timeout does not prove that the first provider request stopped; the completion consumer must therefore be idempotent and must not create a second transcript version or a second support answer. The same discipline applies to the answer contract. Require the fields the support UI needs, validate the retrieved article identifiers separately from the prose, and route invalid structured output to retry or human review. A syntactically valid object with the wrong ticket number is still a failed answer. Infrai should not be selected to solve the unavailable transcription capability. Whisper or rev.ai remains the relevant ASR decision, and AssemblyAI or Deepgram may win after testing the team's corpus. I recommend Infrai to a team that has already chosen its ASR provider and wants ready backend capabilities behind one credential and one bill. That matters when audio ingestion, retrieval, and answer generation are separate services: the team does not have to maintain a separate key and invoice relationship for every backend integration. The migration benefit is concrete. Infrai's public discovery surface exposes capability schemas without requiring a key, and its documented capabilities include runnable examples in 10 languages. An engineer can inspect the contract before writing an adapter and check readiness instead of treating every catalog entry as live. The discovery inventory describes 295 routes across 20 modules, but breadth does not make the unavailable audio route suitable for production ASR. The recommendation is about consolidating the downstream surface, not replacing the transcription specialist. There is a second, separate advantage for this mixed Python and Node.js workflow: the downstream call is plain REST over HTTP, so a service does not need an Infrai-specific SDK installed to use the same contract. That keeps a small worker, a Node.js API, and a later batch process aligned on the same request surface while the ASR adapter remains replaceable. What should the final decision rule be? Choose Whisper when data control and infrastructure ownership are primary requirements. Choose rev.ai when hosted delivery and language coverage carry more weight. Evaluate AssemblyAI and Deepgram against the same recordings, then keep the winner behind the normalized contract. For the private-knowledge-base assistant, make structured-answer correctness the release gate. Word accuracy is useful evidence, not the final product metric. A small transcription error in a greeting may be harmless; a small error in a serial number can send retrieval to the wrong article. The practical sequence is modest: retain only what policy requires, normalize the provider response, make retries idempotent, validate the answer object, and preserve the ability to change the ASR adapter. If the ready-capability boundary fits the downstream portion of the system, the Infrai discovery documentation is the appropriate place to inspect available contracts. Further reading - OpenAI Structured Outputs guide - Whisper repository - rev.ai API documentation - AssemblyAI documentation - Deepgram documentation - Infrai discovery documentation - openai/whisper - docs.rev.ai - assemblyai.com - developers.deepgram.com

讲真，Worktrunk 居然可以让多个 AI agent 各干各的还不互相踩。 再也不用手动敲一串 git worktree 命令了，分支名就是工作区、一条命令切换清理，懂的都懂，赶紧安排。 max-sixty/worktrunk

@kjoshanssen check AxiomMath/CFSGCorollary :)

ShipMBLang 0.7.0 adds objects and richer English context, including methods, inheritance, interfaces, and clearer compiler feedback. These examples were verified with the Windows 0.7.0 executable. qramarq/shipmblang t.co

@kerckhove_ts That's cool! I have thing to make that for generic workloads on GitHub action, trivial (no waterfall) example in the latest nix-reclaim run: github.com/Malix-Labs/GitHub-Action_Nix-Reclaim/a… I guess it could be hooked to the nix daemon so that it could produce the prometheus data and mermaid graph, hmm…

⭐ StableGen ⭐ sakalond/StableGen 1. 블렌더 안에서 AI로 3D 모델을 만들고, 텍스처를 입히고, 움직일 뼈대(리그)까지 넣어주는 오픈소스 애드온 StableGen이 나옴 2. 모델 둘레에 카메라를 놓으면 각 방향 그림을 AI가 그려서 표면에 입혀줌. 앞서 그린 그림을 참고해서 다음 방향을 그리니까 한 바퀴 돌아도 텍스처가 이어짐 3. 캐릭터를 글로 설명하고 미리보기 이미지 하나만 고르면 TRELLIS.2가 모델을 만들고 SkinTokens가 뼈대를 넣고 텍스처까지 한 번에 끝냄. 이미 있는 모델에 텍스처만 입히기도 가능하고, 칠한 부분만 골라 다시 생성도 가능 4. PBR 재질 맵 생성, Mixamo 모션 입히기, 게임 엔진용 내보내기(Godot·웹은 glTF, 언리얼·유니티는 FBX), 3D 프린트용 3MF까지 가능 5. GPL-3.0 무료, 스타 1,239개. Blender 4.2~4.5 또는 5.1 이상(5.0은 미지원)에 ComfyUI 서버 필요. 그래픽 메모리는 SDXL 약 8GB, Qwen Image 16GB 이상. Windows·Linux·Apple Silicon 맥 가능 게임용 캐릭터를 블렌더에서 빠르게 뽑아 보고 싶은 NVIDIA GPU 쓰는 사람한테 좋을 듯 ━━━━━━━━━━ 🇺🇸 1. StableGen is an open-source Blender add-on that generates 3D models, textures them, and even adds a rig (skeleton) for animation, all inside Blender 2. Place cameras around a model and the AI draws a view for each angle and projects it onto the surface. Each view uses the earlier ones as reference, so the texture stays consistent all the way round 3. Describe a character in text and pick one preview image: TRELLIS.2 builds the mesh, SkinTokens adds the skeleton, and the texture is done in one run. It can also texture models you already have, and regenerate only the part you paint over 4. Also makes PBR material maps, retargets Mixamo animations, and exports for game engines (glTF for Godot and the web, FBX for Unreal and Unity), plus 3MF for 3D printing 5. Free under GPL-3.0, 1,239 stars. Needs Blender 4.2-4.5 or 5.1+ (5.0 not supported) and a ComfyUI server. About 8 GB of VRAM for SDXL, 16 GB or more for Qwen Image. Works on Windows, Linux, and Apple Silicon Macs Looks great for anyone with an NVIDIA GPU who wants to quickly spin up game characters inside Blender #AI #Blender #3D #OpenSource #GameDev

Just a scrub. Im a regular dude that loves researching and learning. I need a endorsement for axriv. Im doing this all by myself and github Claude and a few tools I built. I have a few theories and frameworks im working on. I just want help and support of a community who will give me a chance. I have a few papers on zenodo. Even found axiclass bug. I have my own toolkit ready to be tested by astrophysisists and would love an opportunity to show my ideas. They are out of the box but im trying to make sure its scientifically done. All my work is fingerprinted and I use all data sets and I can. I currently have theory that is standing up to ACDM and hopefully soon more data on the quantum side of my work. I have a twist torsion cosmolog and other ideas and projects. I found out I had adhd at 30 plus potentially spectrum qualities and it made me examine myself my life and the universe. So im learning and going my own path. Einstein said to never judge a fish by its ability to swim up a tree. So my approach is foundationally different than standards so im not getting much friction. Here's a look. Id love feedback or mentorship. Id really love to not be stuck doing a job I do not love. I live in oklahoma city. Thank you for your time. Ill leave links in here. zenodo.org dannyeldridge54/AEGIS I apologize if this isn't normal or problematic. I just am reaching out and would l9ve some direction.

做了个桌面小屏，盯着同时在跑的几个 coding agent 平时会在 Paseo 里同时开几个 coding agent （ Claude Code 、Codex 都有），让它们各跑各的长任务。麻烦的是人一走开，就不知道哪个卡在权限确认上、哪个提了问题、哪个已经跑完，只能隔一会儿切回电脑看一眼。 所以做了 Farol ，一块放在桌上的小屏，跑在 ESP-Mosaico 开发板上。  上面是真机录屏（没声音）：按住侧面的 AI 键说一句话，转成文字后按住发送，新会话就开起来了，跑完的结果直接显示在卡片上。 - 主屏是一盏灯。都在干活时冷色慢慢呼吸，有 agent 等你就变琥珀色，失败变红；灯的高低跟着用得最紧的那份额度 - 灯后面是一叠卡片，一个 agent 一张。问题、权限请求、计划都能按住选项直接回答，按住运行中的卡片能停掉这一轮。轻点不会动 agent ，只有按住才算数，免得手滑 - 按住 AI 键说话开新会话，语音转文字用的是 Paseo 自带的语音输入 - 额度页把 Claude 、Codex 、Antigravity 、GLM 这些服务的用量窗口都列出来  实现上有几处可能有人感兴趣。 - 界面用乐鑫的 GSP 画，所有状态和决策都在 Rust 里。板子、模拟器和测试共用同一套逻辑，大部分交互在模拟器里就能调完 - 没有另造一套连接和认证，板子跟 Paseo App 一样连 daemon 。要么扫 Paseo 的配对码走它的中继（ Noise_NK 端到端加密，在板子上用 Rust 实现了一遍），要么局域网 / VPN 直连 - Paseo 那边是个插件，负责把 agent 状态整理成板子能直接用的快照，再替板子执行回答、停止、开会话这些操作。插件已经上了 Paseo 的官方插件目录，paseo plugin add gtoxlili/farol 就能装 - GSP 的文本控件只在空格处换行，中文会直接溢出，所以自己写了按字宽断行的排版。回复里的 Markdown （加粗、列表、代码块）也是先在 Rust 里排好，再分几层标签画出来的 上手门槛不低。得有一块 ESP-Mosaico 开发板，左槽要插摄像头模块，用来扫 Wi-Fi 和配对码；固件需要自己用 ESP-IDF + Rust 编译，README 里有步骤； Paseo 要 0.14 以上。 代码在这里，Apache-2.0： gtoxlili/farol 有类似需求、或者觉得哪里交互别扭的，欢迎拍砖。

Top 5 GitHub Trending Repos Today (Nov 03) #shorts Daily GitHub trending repositories for 2026-11-03. 1. vercel-labs/agent-desktop - A CLI that lets AI agents read and control desktop apps on any OS. vercel-labs/agent-desktop 2. thedotmack/claude-mem - A plugin that gives AI coding agents persistent memory across sessions. thedotmack/claude-mem 3. D4Vinci/Scrapling - A Python framework that scrapes anything, from one page to a full crawl. D4Vinci/Scrapling 4. hyprwm/Hyprland - A tiling Linux window manager with slick animations and deep customization. hyprwm/Hyprland 5. Donchitos/Claude-Code-Game-Studios - A Claude Code setup that acts like a full game studio team of AI agents. Donchitos/Claude-Code-Game-Studios #shorts #github #opensource #programming #coding #developer [ar] أفضل 5 مستودعات رائجة على GitHub اليوم (3 نوفمبر) #shorts أهم مستودعات GitHub الرائجة ليوم 3 نوفمبر 2026. 1. vercel-labs/agent-desktop - واجهة سطر أوامر (CLI) تُمكّن برامج الذكاء الاصطناعي من قراءة تطبيقات سطح المكتب والتحكم بها على أي نظام تشغيل. vercel-labs/agent-desktop 2. thedotmack/claude-mem - إضافة تُتيح لبرامج الذكاء الاصطناعي تخزين البيانات بشكل دائم بين الجلسات. thedotmack/claude-mem 3. D4Vinci/Scrapling - إطار عمل بايثون لاستخراج البيانات من أي مكان، بدءًا من صفحة واحدة وصولًا إلى عملية زحف كاملة. D4Vinci/Scrapling 4. hyprwm/Hyprland - مدير نوافذ لينكس مُجزّأ يتميز برسوم متحركة سلسة وخيارات تخصيص متقدمة. ... hyprwm/Hyprland ٥. Donchitos/Claude-Code-Game-Studios - نظام Claude Code يعمل كفريق استوديو ألعاب كامل من وكلاء الذكاء الاصطناعي. Donchitos/Claude-Code-Game-Studios #shorts #github #opensource #programming #coding #developer [bn] আজকের সেরা ৫টি ট্রেন্ডিং গিটহাব রিপো (৩রা নভেম্বর) #shorts ২০২৬-১১-০৩ তারিখের জন্য দৈনিক গিটহাব ট্রেন্ডিং রিপোজিটরি। ১. vercel-labs/agent-desktop - একটি CLI যা AI এজেন্টদের যেকোনো OS-এ ডেস্কটপ অ্যাপ পড়তে এবং নিয়ন্ত্রণ করতে দেয়। vercel-labs/agent-desktop ২. thedotmack/claude-mem - একটি প্লাগইন যা AI কোডিং এজেন্টদের সেশন জুড়ে স্থায়ী মেমরি প্রদান করে। thedotmack/claude-mem ৩. D4Vinci/Scrapling - একটি পাইথন ফ্রেমওয়ার্ক যা একটি পৃষ্ঠা থেকে শুরু করে সম্পূর্ণ ক্রল পর্যন্ত যেকোনো কিছু স্ক্র্যাপ করে। D4Vinci/Scrapling ৪. hyprwm/Hyprland - চমৎকার অ্যানিমেশন এবং গভীর কাস্টমাইজেশন সহ একটি টাইলিং লিনাক্স উইন্ডো ম্যানেজার। hyprwm/Hyprland ৫. Donchitos/Claude-Code-Game-Studios - একটি ক্লড কোড সেটআপ যা এআই এজেন্টদের একটি সম্পূর্ণ গেম স্টুডিও দলের মতো কাজ করে। Donchitos/Claude-Code-Game-Studios #shorts #github #opensource #programming #coding #developer [de-DE] Die 5 aktuell angesagtesten GitHub-Repos (03. Nov) #shorts Tägliche GitHub-Trend-Repositories vom 03.11.2026. 1. vercel-labs/agent-desktop – Eine CLI, mit der KI-Agenten Desktop-Anwendungen auf jedem Betriebssystem lesen und steuern können. vercel-labs/agent-desktop 2. thedotmack/claude-mem – Ein Plugin, das KI-Codierungsagenten sitzungsübergreifenden Speicher zur Verfügung stellt. thedotmack/claude-mem 3. D4Vinci/Scrapling – Ein Python-Framework zum Scrapen beliebiger Daten, von einzelnen Seiten bis hin zu kompletten Web-Crawls. D4Vinci/Scrapling 4. hyprwm/Hyprland – Ein Tiling-Window-Manager für Linux mit eleganten Animationen und umfangreichen Anpassungsmöglichkeiten. hyprwm/Hyprland 5. Donchitos/Claude-Code-Game-Studios – Ein Claude-Code-Setup, das wie ein komplettes KI-gestütztes Spieleentwicklungsteam agiert. Donchitos/Claude-Code-Game-Studios #shorts #github #opensource #programming #coding #developer [es-US] Los 5 repositorios de GitHub en tendencia hoy (03 de nov.) #shorts Repositorios más populares de GitHub (3 de noviembre de 2026). 1. vercel-labs/agent-desktop: Una interfaz de línea de comandos que permite a los agentes de IA leer y controlar aplicaciones de escritorio en cualquier sistema operativo. vercel-labs/agent-desktop 2. thedotmack/claude-mem: Un plugin que proporciona a los agentes de codificación de IA memoria persistente entre sesiones. thedotmack/claude-mem 3. D4Vinci/Scrapling: Un framework de Python que extrae información de cualquier tipo, desde una página hasta un rastreo completo. D4Vinci/Scrapling 4. hyprwm/Hyprland: Un gestor de ventanas de Linux con estructura de mosaico, animaciones fluidas y amplias opciones de personalización. hyprwm/Hyprland 5. Donchitos/Claude-Code-Game-Studios: Una configuración de Claude Code que funciona como un equipo completo de agentes de IA en un estudio de videojuegos. Donchitos/Claude-Code-Game-Studios #shorts #github #opensource #programming #coding #developer [fr-FR] Top 5 des dépôts GitHub tendances du jour (03 nov.) #shorts Dépôts GitHub les plus populaires du jour (03/11/2026) : 1. vercel-labs/agent-desktop : Une interface en ligne de commande (CLI) permettant aux agents d'IA de lire et de contrôler des applications de bureau sur n'importe quel système d'exploitation. vercel-labs/agent-desktop 2. thedotmack/claude-mem : Un plugin offrant aux agents de programmation d'IA une mémoire persistante entre les sessions. thedotmack/claude-mem 3. D4Vinci/Scrapling : Un framework Python permettant d'extraire des données de n'importe quelle page, ou de réaliser un crawl complet. D4Vinci/Scrapling 4. hyprwm/Hyprland : Un gestionnaire de fenêtres en mosaïque pour Linux, avec des animations fluides et une personnalisation poussée. hyprwm/Hyprland 5. Donchitos/Claude-Code-Game-Studios : Une configuration Claude Code qui fonctionne comme une véritable équipe de studio de jeux vidéo composée d'agents IA. Donchitos/Claude-Code-Game-Studios #shorts #github #opensource #programming #coding #developer [hi] आज के टॉप 5 GitHub ट्रेंडिंग रिपोज़ (03 नवंबर) #shorts 3 नवंबर 2026 के लिए GitHub पर दैनिक ट्रेंडिंग रिपॉजिटरी। 1. vercel-labs/agent-desktop - एक CLI जो AI एजेंटों को किसी भी ऑपरेटिंग सिस्टम पर डेस्कटॉप ऐप्स को पढ़ने और नियंत्रित करने की सुविधा देता है। vercel-labs/agent-desktop 2. thedotmack/claude-mem - एक प्लगइन जो AI कोडिंग एजेंटों को सत्रों के दौरान स्थायी मेमोरी प्रदान करता है। thedotmack/claude-mem 3. D4Vinci/Scrapling - एक Python फ्रेमवर्क जो एक पेज से लेकर पूरे डेटा को स्क्रैप कर सकता है। D4Vinci/Scrapling 4. hyprwm/Hyprland - एक टाइलिंग लिनक्स विंडो मैनेजर जिसमें आकर्षक एनिमेशन और व्यापक अनुकूलन विकल्प उपलब्ध हैं। hyprwm/Hyprland 5. Donchitos/Claude-Code-Game-Studios - एक क्लाउड कोड सेटअप जो एआई एजेंटों की एक पूरी गेम स्टूडियो टीम की तरह काम करता है। Donchitos/Claude-Code-Game-Studios #shorts #github #opensource #programming #coding #developer [id] 5 Repo GitHub Paling Trending Hari Ini (3 Nov) #shorts Repositori GitHub yang sedang tren setiap hari untuk tanggal 3 November 2026. 1. vercel-labs/agent-desktop - Sebuah CLI yang memungkinkan agen AI untuk membaca dan mengontrol aplikasi desktop di sistem operasi apa pun. vercel-labs/agent-desktop 2. thedotmack/claude-mem - Sebuah plugin yang memberikan memori persisten kepada agen pengkodean AI di seluruh sesi. thedotmack/claude-mem 3. D4Vinci/Scrapling - Sebuah framework Python yang melakukan scraping apa pun, dari satu halaman hingga crawling penuh. D4Vinci/Scrapling 4. hyprwm/Hyprland - Sebuah pengelola jendela Linux berbasis tiling dengan animasi yang apik dan kustomisasi mendalam. hyprwm/Hyprland 5. Donchitos/Claude-Code-Game-Studios - Sebuah pengaturan Claude Code yang bertindak seperti tim studio game lengkap yang terdiri dari agen AI. Donchitos/Claude-Code-Game-Studios #shorts #github #opensource #programming #coding #developer [it] I 5 repository GitHub di tendenza oggi (3 novembre) #shorts Repository di tendenza su GitHub del 3 novembre 2026. 1. vercel-labs/agent-desktop - Un'interfaccia a riga di comando (CLI) che permette agli agenti IA di leggere e controllare le applicazioni desktop su qualsiasi sistema operativo. vercel-labs/agent-desktop 2. thedotmack/claude-mem - Un plugin che fornisce agli agenti di programmazione IA memoria persistente tra le sessioni. thedotmack/claude-mem 3. D4Vinci/Scrapling - Un framework Python per lo scraping di qualsiasi contenuto, da una singola pagina a una scansione completa. D4Vinci/Scrapling 4. hyprwm/Hyprland - Un window manager per Linux con finestre affiancate, animazioni fluide e ampie possibilità di personalizzazione. Italiano: hyprwm/Hyprland 5. Donchitos/Claude-Code-Game-Studios - Una configurazione di Claude Code che si comporta come un team completo di agenti IA per lo sviluppo di videogiochi. Donchitos/Claude-Code-Game-Studios #shorts #github #opensource #programming #coding #developer [iw] 5 מאגרי ה-GitHub המובילים במגמת עלייה היום (3 בנובמבר) #shorts מאגרים יומיים של GitHub לטרנדים לשנת 2026-11-03. 1. vercel-labs/agent-desktop - ממשק שורת פקודה (CLI) המאפשר לסוכני בינה מלאכותית לקרוא ולשלוט באפליקציות שולחן עבודה בכל מערכת הפעלה. vercel-labs/agent-desktop 2. thedotmack/claude-mem - תוסף המעניק לסוכני קידוד בינה מלאכותית זיכרון מתמשך לאורך הפעלות. thedotmack/claude-mem 3. D4Vinci/Scrapling - מסגרת Python שמגרדת כל דבר, מדף אחד ועד סריקה מלאה. D4Vinci/Scrapling 4. hyprwm/Hyprland - מנהל חלונות לינוקס עם אנימציות חלקות והתאמה אישית עמוקה. hyprwm/Hyprland 5. Donchitos/Claude-Code-Game-Studios - מערך של Claude Code שפועל כמו צוות סטודיו מלא של סוכני בינה מלאכותית. Donchitos/Claude-Code-Game-Studios #shorts #github #opensource #programming #coding #developer [ja] 今日のGitHubトレンドリポジトリTOP5（11月3日） #shorts 2026年11月3日のGitHubトレンドリポジトリ（日別） 1. vercel-labs/agent-desktop - あらゆるOS上のデスクトップアプリをAIエージェントが読み取り、制御できるCLI。 vercel-labs/agent-desktop 2. thedotmack/claude-mem - AIコーディングエージェントにセッション間で永続的なメモリを提供するプラグイン。 thedotmack/claude-mem 3. D4Vinci/Scrapling - 1ページからフルクロールまで、あらゆるものをスクレイピングできるPythonフレームワーク。 D4Vinci/Scrapling 4. hyprwm/Hyprland - 洗練されたアニメーションと高度なカスタマイズ機能を備えたタイル型Linuxウィンドウマネージャー。 hyprwm/Hyprland 5. Donchitos/Claude-Code-Game-Studios - AIエージェントで構成された本格的なゲームスタジオチームのように動作するClaude Codeのセットアップ。 Donchitos/Claude-Code-Game-Studios #shorts #github #opensource #programming #coding #developer [ko] 오늘의 GitHub 트렌딩 저장소 TOP 5 (11월 3일) #shorts 2026년 11월 3일 기준 GitHub 인기 저장소 목록입니다. 1. vercel-labs/agent-desktop - AI 에이전트가 모든 운영체제의 데스크톱 앱을 읽고 제어할 수 있도록 해주는 CLI 도구입니다. vercel-labs/agent-desktop 2. thedotmack/claude-mem - AI 코딩 에이전트에게 세션 간 영구 메모리를 제공하는 플러그인입니다. thedotmack/claude-mem 3. D4Vinci/Scrapling - 한 페이지부터 전체 크롤링까지 모든 것을 스크래핑할 수 있는 Python 프레임워크입니다. D4Vinci/Scrapling 4. hyprwm/Hyprland - 세련된 애니메이션과 풍부한 사용자 정의 기능을 제공하는 타일링 방식의 Linux 윈도우 관리자입니다. hyprwm/Hyprland 5. Donchitos/Claude-Code-Game-Studios - AI 에이전트로 구성된 완전한 게임 스튜디오 팀처럼 작동하는 Claude Code 환경입니다. Donchitos/Claude-Code-Game-Studios #shorts #github #opensource #programming #coding #developer [ml] ഇന്നത്തെ മികച്ച 5 ഗിറ്റ്‌ഹബ് ട്രെൻഡിംഗ് റിപ്പോസിറ്ററികൾ (നവംബർ 03) #shorts 2026-11-03-ലെ ദൈനംദിന GitHub ട്രെൻഡിംഗ് ശേഖരണങ്ങൾ. 1. vercel-labs/agent-desktop - ഏത് OS-ലും ഡെസ്‌ക്‌ടോപ്പ് ആപ്പുകൾ വായിക്കാനും നിയന്ത്രിക്കാനും AI ഏജന്റുമാരെ അനുവദിക്കുന്ന ഒരു CLI. vercel-labs/agent-desktop 2. thedotmack/claude-mem - സെഷനുകളിലുടനീളം AI കോഡിംഗ് ഏജന്റുമാർക്ക് സ്ഥിരമായ മെമ്മറി നൽകുന്ന ഒരു പ്ലഗിൻ. thedotmack/claude-mem 3. D4Vinci/Scrapling - ഒരു പേജ് മുതൽ പൂർണ്ണ ക്രാൾ വരെയുള്ള എന്തും സ്ക്രാപ്പ് ചെയ്യുന്ന ഒരു പൈത്തൺ ഫ്രെയിംവർക്ക്. D4Vinci/Scrapling 4. hyprwm/Hyprland - സ്ലിക്ക് ആനിമേഷനുകളും ആഴത്തിലുള്ള ഇഷ്‌ടാനുസൃതമാക്കലും ഉള്ള ഒരു ടൈലിംഗ് ലിനക്സ് വിൻഡോ മാനേജർ. hyprwm/Hyprland 5. ഡോഞ്ചിറ്റോസ്/ക്ലോഡ്-കോഡ്-ഗെയിം-സ്റ്റുഡിയോസ് - AI ഏജന്റുമാരുടെ ഒരു പൂർണ്ണ ഗെയിം സ്റ്റുഡിയോ ടീം പോലെ പ്രവർത്തിക്കുന്ന ഒരു ക്ലോഡ് കോഡ് സജ്ജീകരണം. Donchitos/Claude-Code-Game-Studios #ഷോർട്ട്സ് #ഗിത്തബ് #ഓപ്പൺസോഴ്‌സ് #പ്രോഗ്രാമിംഗ് #കോഡിംഗ് #ഡെവലപ്പർ [nl-NL] Top 5 trending GitHub-repositories van vandaag (3 nov) #shorts Dagelijkse trending repositories op GitHub voor 3 november 2026. 1. vercel-labs/agent-desktop - Een CLI waarmee AI-agenten desktopapplicaties op elk besturingssysteem kunnen lezen en besturen. vercel-labs/agent-desktop 2. thedotmack/claude-mem - Een plugin die AI-codeeragenten persistent geheugen biedt tussen sessies. thedotmack/claude-mem 3. D4Vinci/Scrapling - Een Python-framework dat alles kan scrapen, van één pagina tot een volledige crawl. D4Vinci/Scrapling 4. hyprwm/Hyprland - Een tiling Linux-vensterbeheerder met vloeiende animaties en uitgebreide aanpassingsmogelijkheden. hyprwm/Hyprland 5. Donchitos/Claude-Code-Game-Studios - Een Claude Code-opstelling die functioneert als een volledig gamestudio-team van AI-agenten. Donchitos/Claude-Code-Game-Studios #shorts #github #opensource #programming #coding #developer [pa] ਅੱਜ ਦੇ ਚੋਟੀ ਦੇ 5 GitHub ਟ੍ਰੈਂਡਿੰਗ ਰੈਪੋ (03 ਨਵੰਬਰ) #shorts 2026-11-03 ਲਈ ਰੋਜ਼ਾਨਾ GitHub ਟ੍ਰੈਂਡਿੰਗ ਰਿਪੋਜ਼ਟਰੀਆਂ। 1. vercel-labs/agent-desktop - ਇੱਕ CLI ਜੋ AI ਏਜੰਟਾਂ ਨੂੰ ਕਿਸੇ ਵੀ OS 'ਤੇ ਡੈਸਕਟੌਪ ਐਪਸ ਨੂੰ ਪੜ੍ਹਨ ਅਤੇ ਕੰਟਰੋਲ ਕਰਨ ਦਿੰਦਾ ਹੈ। vercel-labs/agent-desktop 2. thedotmack/claude-mem - ਇੱਕ ਪਲੱਗਇਨ ਜੋ AI ਕੋਡਿੰਗ ਏਜੰਟਾਂ ਨੂੰ ਸੈਸ਼ਨਾਂ ਵਿੱਚ ਸਥਾਈ ਮੈਮੋਰੀ ਦਿੰਦਾ ਹੈ। thedotmack/claude-mem 3. D4Vinci/Scrapling - ਇੱਕ ਪਾਈਥਨ ਫਰੇਮਵਰਕ ਜੋ ਇੱਕ ਪੰਨੇ ਤੋਂ ਲੈ ਕੇ ਇੱਕ ਪੂਰੇ ਕ੍ਰੌਲ ਤੱਕ ਕਿਸੇ ਵੀ ਚੀਜ਼ ਨੂੰ ਸਕ੍ਰੈਪ ਕਰਦਾ ਹੈ। D4Vinci/Scrapling 4. hyprwm/Hyprland - ਸਲੀਕ ਐਨੀਮੇਸ਼ਨਾਂ ਅਤੇ ਡੂੰਘੀ ਅਨੁਕੂਲਤਾ ਵਾਲਾ ਇੱਕ ਟਾਈਲਿੰਗ ਲੀਨਕਸ ਵਿੰਡੋ ਮੈਨੇਜਰ। hyprwm/Hyprland 5. Donchitos/Claude-Code-Game-Studios - ਇੱਕ Claude ਕੋਡ ਸੈੱਟਅੱਪ ਜੋ AI ਏਜੰਟਾਂ ਦੀ ਇੱਕ ਪੂਰੀ ਗੇਮ ਸਟੂਡੀਓ ਟੀਮ ਵਾਂਗ ਕੰਮ ਕਰਦਾ ਹੈ। Donchitos/Claude-Code-Game-Studios #shorts #github #opensource #programming #coding #developer [pl] Top 5 trendujących repozytoriów GitHub dzisiaj (3 listopada) #shorts Codzienne trendy w repozytoriach GitHub na dzień 03.11.2026. 1. vercel-labs/agent-desktop – Interfejs wiersza poleceń (CLI), który umożliwia agentom AI odczytywanie i kontrolowanie aplikacji desktopowych w dowolnym systemie operacyjnym. vercel-labs/agent-desktop 2. thedotmack/claude-mem – Wtyczka, która zapewnia agentom kodującym AI trwałą pamięć między sesjami. thedotmack/claude-mem 3. D4Vinci/Scrapling – Framework Pythona, który skanuje wszystko, od jednej strony po pełne skanowanie. D4Vinci/Scrapling 4. hyprwm/Hyprland – Kafelkowy menedżer okien dla Linuksa z efektownymi animacjami i bogatymi możliwościami personalizacji. hyprwm/Hyprland 5. Donchitos/Claude-Code-Game-Studios – Konfiguracja Claude Code, która działa jak pełny zespół agentów AI studia gier. Donchitos/Claude-Code-Game-Studios #shorts #github #opensource #programowanie #kodowanie #programista [pt-BR] Os 5 Repositórios do GitHub em Alta Hoje (03/nov) #shorts Repositórios em alta no GitHub em 03/11/2026. 1. vercel-labs/agent-desktop - Uma CLI que permite que agentes de IA leiam e controlem aplicativos de desktop em qualquer sistema operacional. vercel-labs/agent-desktop 2. thedotmack/claude-mem - Um plugin que fornece memória persistente para agentes de IA de codificação entre sessões. thedotmack/claude-mem 3. D4Vinci/Scrapling - Um framework Python que extrai dados de qualquer coisa, desde uma única página até uma busca completa. D4Vinci/Scrapling 4. hyprwm/Hyprland - Um gerenciador de janelas em mosaico para Linux com animações elegantes e opções avançadas de personalização. hyprwm/Hyprland 5. Donchitos/Claude-Code-Game-Studios - Uma configuração do Claude Code que funciona como uma equipe completa de agentes de IA de um estúdio de jogos. Donchitos/Claude-Code-Game-Studios #shorts #github #opensource #programming #coding #developer [ru] Топ-5 трендовых репозиториев GitHub сегодня (3 ноября) #shorts Популярные репозитории GitHub за 03.11.2026: 1. vercel-labs/agent-desktop — CLI-интерфейс, позволяющий ИИ-агентам читать и управлять настольными приложениями на любой ОС. vercel-labs/agent-desktop 2. thedotmack/claude-mem — плагин, предоставляющий ИИ-агентам постоянную память между сессиями. thedotmack/claude-mem 3. D4Vinci/Scrapling — Python-фреймворк, позволяющий парсить что угодно, от одной страницы до полного обхода. D4Vinci/Scrapling 4. hyprwm/Hyprland — оконный менеджер Linux с мозаичным расположением окон, эффектной анимацией и широкими возможностями настройки. hyprwm/Hyprland 5. Donchitos/Claude-Code-Game-Studios — студия разработки игр на Claude Code, которая функционирует как полноценная команда ИИ-агентов. Donchitos/Claude-Code-Game-Studios #shorts #github #opensource #programming #coding #developer [ta] இன்றைய டாப் 5 கிட்ஹப் ட்ரெண்டிங் ரிப்போக்கள் (நவம்பர் 03) #shorts 2026-11-03-க்கான தினசரி GitHub பிரபல ரெப்போசிட்டரிகள். 1. vercel-labs/agent-desktop - எந்தவொரு OS-இலும் AI ஏஜென்ட்கள் டெஸ்க்டாப் செயலிகளைப் படிக்கவும் கட்டுப்படுத்தவும் அனுமதிக்கும் ஒரு CLI. vercel-labs/agent-desktop 2. thedotmack/claude-mem - AI கோடிங் ஏஜென்ட்களுக்கு செஷன்களுக்கு இடையில் நிலையான நினைவகத்தை வழங்கும் ஒரு பிளகின். thedotmack/claude-mem 3. D4Vinci/Scrapling - ஒரு பக்கம் முதல் முழுமையான க்ரால் வரை எதையும் ஸ்கிரேப் செய்யும் ஒரு பைதான் ஃபிரேம்வொர்க். D4Vinci/Scrapling 4. hyprwm/Hyprland - நேர்த்தியான அனிமேஷன்கள் மற்றும் ஆழமான தனிப்பயனாக்கத்துடன் கூடிய ஒரு டைலிங் லினக்ஸ் விண்டோ மேனேஜர். hyprwm/Hyprland 5. Donchitos/Claude-Code-Game-Studios - ஒரு முழுமையான கேம் ஸ்டுடியோவின் AI ஏஜென்ட்கள் குழுவைப் போல செயல்படும் ஒரு கிளாட் கோட் அமைப்பு. Donchitos/Claude-Code-Game-Studios #குறுஞ்செய்திகள் #கிட்ஹப் #திறந்தமூலம் #நிரலாக்கம் #குறியீடாக்கம் #டெவலப்பர் [te] ఈరోజు టాప్ 5 GitHub ట్రెండింగ్ రిపోలు (నవంబర్ 03) #shorts 2026-11-03 నాటి రోజువారీ గిట్‌హబ్ ట్రెండింగ్ రిపోజిటరీలు. 1. vercel-labs/agent-desktop - ఏ ఆపరేటింగ్ సిస్టమ్‌లోనైనా డెస్క్‌టాప్ యాప్‌లను చదవడానికి మరియు నియంత్రించడానికి AI ఏజెంట్లను అనుమతించే ఒక CLI. vercel-labs/agent-desktop 2. thedotmack/claude-mem - AI కోడింగ్ ఏజెంట్లకు సెషన్‌ల అంతటా నిరంతర మెమరీని అందించే ఒక ప్లగిన్. thedotmack/claude-mem 3. D4Vinci/Scrapling - ఒక పేజీ నుండి పూర్తి క్రాల్ వరకు దేనినైనా స్క్రాప్ చేసే ఒక పైథాన్ ఫ్రేమ్‌వర్క్. D4Vinci/Scrapling 4. hyprwm/Hyprland - ఆకర్షణీయమైన యానిమేషన్లు మరియు విస్తృతమైన అనుకూలీకరణతో కూడిన ఒక టైలింగ్ లైనక్స్ విండో మేనేజర్. hyprwm/Hyprland 5. డాంచిటోస్/క్లాడ్-కోడ్-గేమ్-స్టూడియోస్ - ఇది AI ఏజెంట్లతో కూడిన పూర్తి గేమ్ స్టూడియో బృందంలా పనిచేసే ఒక క్లాడ్ కోడ్ సెటప్. Donchitos/Claude-Code-Game-Studios #షార్ట్స్ #గిట్‌హబ్ #ఓపెన్‌సోర్స్ #ప్రోగ్రామింగ్ #కోడింగ్ #డెవలపర్ [uk] Топ-5 трендових репозиторіїв GitHub сьогодні (3 листопада) #shorts Щоденні трендові репозиторії GitHub за 2026-11-03. 1. vercel-labs/agent-desktop – CLI, що дозволяє агентам ШІ читати та керувати програмами для робочого столу на будь-якій ОС. vercel-labs/agent-desktop 2. thedotmack/claude-mem – плагін, який надає агентам ШІ-кодування постійну пам'ять між сеансами. thedotmack/claude-mem 3. D4Vinci/Scrapling – фреймворк Python, який витягує будь-що, від однієї сторінки до повного сканування. D4Vinci/Scrapling 4. hyprwm/Hyprland – віконний менеджер Linux з мозаїчними анімаціями та глибоким налаштуванням. hyprwm/Hyprland 5. Donchitos/Claude-Code-Game-Studios – система Claude Code, яка діє як повноцінна команда ігрової студії зі штучним інтелектом. Donchitos/Claude-Code-Game-Studios #короткі_ролики #github #відкритий_код #програмування #кодування #розробник

A Chatgpt intergrated fork of PhotoCraft Last week, I switched from Photoshop to PhotoCraft. So far, it’s been great. It has a CLI and MCP support that let Codex connect to it, but I don’t like switching over to Codex to write prompts while I’m editing an image. So I built AI features directly into the interface. That way, I wouldn’t have to keep switching between the editor and the AI. It uses Chatgpt subscription, if you already have one, you don't need to spend extra money on AI. You can find it here. github.com/BLEZZ0102/photocraft-ai/releases/tag/v… Please note: this is my fork, not the official version of PhotoCraft. The official version doesn’t have these features yet. If you don’t have a paid ChatGPT subscription, or you’d like to use other image generation models, you can also connect through an API. Currently supported options include Nano Banana through the Gemini API, FLUX through its API, and ByteDance’s Seedream through the Volcengine API. Update on plugin support: Many people asked whether this could be a PhotoCraft plugin. The main limitation is PhotoCraft’s current plugin API: it’s designed for sandboxed image filters and doesn’t expose the service access, Codex runtime integration, or UI and document operations this workflow needs. I’ve now drafted an extension proposal and opened an issue to discuss it with the maintainers: photocraft#11014 The proposed first step is a small working example using a mock service, with a prompt form, a cancellable background task, and a result added as an undoable layer. Actual AI services would come afterward, while keeping existing plugins compatible. There isn’t an installable AI plugin yet—I’m seeking feedback on the API design before starting implementation. My existing PR for AI editing built directly into PhotoCraft is separate: photocraft#10593 Thanks to everyone who suggested the plugin approach!

Spent the afternoon putting away Halloween decorations, but also thinking about turning an old Raspberry Pi into a Roland MT-32 emulator. dwhinham/mt32-pi

Red teaming needs the right arsenal. My Red-Team-Tools repo curates C2 frameworks and adversary simulation resources for real engagements. Gear up at yogsec/Red-Team-Tools #redteam #pentesting #cybersecurity #infosec #github

@kohira_innocord おぉ、お知らせありがとうございます。 ちな、issueはこちらです。 ipsum#177

DiscImageStudio: burn visible artwork onto CDs, DVDs and Blu-ray discs JiaFeiMiao-K-Cat/DiscImageStudio (news.ycombinator.com)

vibe coding is fun haha. swizzlez/spark was surprised slack didn't have a native /poll... now i can multi-player team based snake instead of work! lol

有点意思，想看清一套像素立体渲染是怎么从零写出来的，翻成品游戏通常只能看到编译产物和贴图。 这里用五个无构建、无依赖的单页游戏演示一套等距像素立体感渲染规则，相机、深度、抖动、阴影都摊在代码里可读可改。 amirmushichge/pixel-plays t.co

He creado GamesDock: un dock gratuito y superligero para organizar juegos y apps en Windows ☕ (un Rocket Launcher, pero bien, también en inglés) He creado GamesDock: un dock gratuito para juegos y apps personalizable, con SteamGridDB integrado 🎮 ¡Hola! Quería enseñaros GamesDock, un proyecto que estoy desarrollando para organizar juegos y aplicaciones en Windows y dejar el escritorio más limpio. Su función más interesante es la integración con la API de SteamGridDB: desde el propio dock puedes buscar los iconos que comparte la comunidad, ver sus miniaturas y elegir uno para tu juego. Se descarga y aplica directamente, sin tener que buscar la imagen en el navegador ni guardarla a mano. Solo necesitas una clave gratuita de SteamGridDB. También permite: - Detectar juegos de Steam, Epic y GOG, además de aplicaciones y accesos del escritorio. - Añadir accesos arrastrándolos, reordenarlos, marcar favoritos y agruparlos en carpetas. - Ver una ficha del juego al pasar el ratón, con banner y datos de Steam. - Elegir entre 15 temas, incluidos seis animados con efectos propios, y probar combinaciones en una muestra interactiva. - Personalizar tamaño y forma de los iconos, agrandado y animaciones. - Colocar la barra en cualquier borde o libremente, bloquearla y mostrarla u ocultarla con un atajo. - Mover los accesos del escritorio al dock y devolverlos después. - Usarlo en español o inglés, iniciarlo con Windows y buscar actualizaciones desde la aplicación. Es gratuito, de código abierto y sin instalador: un único ejecutable para Windows 10/11 de 64 bits con .NET Framework 4.8. Os dejo unas capturas y el repositorio, donde también podéis descargarlo 😊 👉 GitHub: sadri-99/GAMESDOCK Si lo probáis, me encantará leer vuestras ideas, sugerencias o cualquier fallo que encontréis. ¡Gracias por echarle un vistazo!

Yes there's always going to be more. New stalkers were found recently and other exploits are being discovered as previous ones get fixed. See: report#5 h

Red teaming needs the right arsenal. My Red-Team-Tools repo curates C2 frameworks and adversary simulation resources for real engagements. Gear up at yogsec/Red-Team-Tools #redteam #pentesting #cybersecurity #infosec #GitHub

Votehub made a fucking CLI for election data lmao de-bayes/votehub-cli

webAC update: play Coldeve, Leaftide, Levistras or any of 50+ AC servers in your browser, no install Quick update on webAC, the browser client I posted here a few weeks ago. If you missed it: it's the easiest way I know to play Asheron's Call on existing servers in 2026. Go to playwebac.com, pick a server, log in with your normal account. No install, no game files, no launcher, no Decal. It's not a new server. It connects to the servers you already play on, as they are: Coldeve, InfiniteLeaftide, PortalStorm, Levistras, AC1999, and the rest of the list, with the same accounts and characters you use in the regular client. The goal is getting more people onto the servers we already have, not splitting the population up even more. If you've got a friend who quit because setup was a pain, this is a link you can send them. What's new since the last post: - VTank and UtilityBelt are built in, no Decal needed. Combat macro, nav routes, metas and VTClassic loot profiles, in a window laid out like the real VTank. Bring your own .nav / .met / .utl files. UB tools like dungeon maps and autovendor work too. Please follow your server's macro rules. - 15 bug reports on GitHub were filed and many more via comments and DMs (thank you!) All are fixed, most within a few hours, none took longer than a day - Firefox and Safari work a lot better: no freeze going through portals, the mouse wheel behaves, sound comes back if it cuts out - If your connection drops you get put back in on your own, even in the middle of making a character - Each server looks like its own era now. The pics are the same spot in Holtburg on an end of retail, a Dark Majesty and a 1999 server. - A few hundred smaller fixes How to play: playwebac.com Keep the bug reports coming, here, on GitHub, or by DM. Thanks to everyone who's been playing, and happy 27th to Dereth!

Is Qwen Code Really Free? A Practical Setup and Pricing Guide (2026) Qwen Code is an open-source AI coding agent that can inspect repositories, edit files, execute commands, and connect to different AI model providers. But there's a question that often causes confusion: Is Qwen Code actually free, or do you need to pay for an API key? The short answer: the client is free, but the AI models you connect to it may not be. And if you're following an older tutorial that recommends signing in with Qwen OAuth for free usage, that advice is now outdated. Here's how Qwen Code works in 2026 and how to set it up without choosing the wrong authentication or billing method. 1. What is free, and what costs money? Qwen Code itself is an open-source application licensed under Apache 2.0. You can install the client without purchasing a software license. However, the client still needs access to an AI model. There are several ways to provide that access: | Connection | How billing generally works | |---|---| | QwenCloud Token Plan | Subscription with a monthly credit quota | | QwenCloud Standard API Key | Pay-as-you-go API usage | | Alibaba ModelStudio Coding Plan | Subscription with an included usage quota | | Alibaba ModelStudio Token Plan | Usage-based billing through a dedicated endpoint | | Alibaba ModelStudio Standard API Key | Pay-as-you-go API usage | | Third-party model provider | Depends on that provider's pricing | | Self-hosted local model | No hosted inference charge, but requires your own hardware | This distinction matters. Installing a free coding agent does not automatically give you unlimited free access to the models it uses. Also, QwenCloud Token Plan and Alibaba ModelStudio Token Plan are separate offerings. Do not assume that a key or subscription for one automatically works with the other. 2. Install Qwen Code For an npm installation, first check that you have Node.js 22 or later. node --version Then install Qwen Code: npm install -g @qwen-code/qwen-code@latest On macOS or Linux, Homebrew is another documented installation option: brew install qwen-code Navigate to a project directory and launch the client: cd your-project qwen The first launch will guide you through provider authentication. Official installation guide: Qwen Code Quickstart. 3. Choose the right authentication method Inside the running Qwen Code interface, enter: /auth You'll be able to choose from supported connection types. Option A: QwenCloud This is a straightforward option if you want to use QwenCloud directly. You can choose between: - Token Plan: a subscription with a monthly credit quota. - Standard API Key: pay for API usage based on the provider's pricing. Select the correct regional platform and enter the key issued for that service. Option B: Alibaba ModelStudio Alibaba ModelStudio provides several choices, including Coding Plan, Token Plan, and Standard API Key. These offerings differ in their intended users, quotas, billing rules, and endpoints. For example, Coding Plan is oriented toward individual developers with an included usage quota. Token Plan uses a separate usage-based endpoint. Choose the specific offering that matches your account and API key. Option C: Third-party providers Qwen Code can also connect to supported third-party model providers. This can make sense if you already have an API account elsewhere or want more flexibility over which model you use. You should verify the provider's supported models, usage terms, and pricing before connecting. Option D: Custom or local provider Qwen Code supports custom model connections, including compatible locally hosted model servers. For example, a local inference server exposing an OpenAI-compatible endpoint may be configured as a model provider. This can avoid hosted-model API charges, but it doesn't guarantee every tool or feature works entirely offline. 4. Important: the old free Qwen OAuth option is gone This is one of the biggest changes to watch out for. The previous Qwen OAuth free tier was discontinued on April 15, 2026. As a result, some older installation videos and blog posts may describe a sign-in path that is no longer available for normal use. If an old tutorial tells you to rely on free Qwen OAuth access, check the current official documentation instead. The current recommended workflow is to launch qwen and configure an available provider through /auth. Also note that the old standalone qwen auth CLI command has been removed in the current documentation. The interactive /auth command is entered inside Qwen Code, not directly in your shell. Official reference: Qwen Code Authentication. 5. Check your connection and select a model Once authentication is complete, you can use these commands inside Qwen Code: /doctor Check your environment and authentication configuration. /model Choose from the models available through your configured providers. /help Show the currently available commands. Before running an expensive repository-wide task, try a small request first. For example: > Inspect this repository and explain its main modules. Do not modify any files. Then verify that the selected model responds correctly and that the provider's usage is being recorded as expected. Never commit your API keys to a Git repository. 6. Which setup should you choose? Here's a practical way to decide: You already pay for an API provider: Check whether Qwen Code supports that provider and whether your existing credentials are eligible. You want predictable usage within an included quota: Compare the current subscription and quota terms of the relevant QwenCloud or Alibaba ModelStudio plan. You prefer usage-based billing: Choose an appropriate Standard API Key or usage-based provider connection. You want to run models locally: Check your available hardware, local inference server, model compatibility, and offline requirements. There isn't one universally cheapest option. The total cost depends on the model, workload, quota, cache behavior, and provider terms. 7. A final recommendation Before committing to a paid plan, do three things: 1. Confirm that your intended model is supported by your chosen provider. 2. Run a small real coding task and inspect the result. 3. Check the provider's billing dashboard or quota usage. A free client is useful, but the right model connection determines much of the actual experience and cost. For a source-backed overview of Qwen Code, including its model and API relationships, I've also put together a reference page on iilib — Qwen Code. Official references - Qwen Code Quickstart - Qwen Code Authentication - Qwen Code Model Providers Documentation reviewed: November 2026. Model availability, authentication options and pricing may change. Which provider are you using with Qwen Code, and what has your setup experience been like?

alongside the overkills for package management for pond.cat , it will of course have an install script. go star the repository, i added a kitty, cmon 0x4bs3nt/pond t.co

I built Rustel: a native Strudel engine in Rust, with a terminal studio and full CLI Hey everyone, I've been working on Rustel, a native Rust port of Strudel, and thought some of you might be interested. It runs Strudel patterns without needing a browser or server. There's a terminal studio with live editing, piano roll, scope, spectrum, and mixer. The studio has a built-in Vim editing mode and optional auto-evaluate, so changes apply automatically after a short typing pause without constantly hitting the eval shortcut. You can also livecode in any editor without extra setup using rustel play --watch yourScore.strudel, or use the full CLI for everything. It supports samples, synths, effects, MIDI, OSC, Ableton Link, VST3 plugins, KabelSalat, Audio Input using s("in") for example, exporting with silence threshold, exporting stems, session tapes (nothing you play is ever lost), midi surface control + gamepad and midi knobs to control sliders, Kitty Graphics... and quite a bit more. I'm also working on v0.1.7, with some performance optimizations for older hardware like the Raspberry Pi 3 Model B (PR #157) and video samples with live feeds (PR #169). I recorded some demos of it in action. It's 99% strudel feature complete + a lot more, the differences are documented. It's free and open source (AGPL): rustel.cc tzfm/rustel tzfm/rustel-neovim Big thanks to everyone behind Strudel and TidalCycles. None of this would exist without their work. My friend John Björk also made 3 songs with it here: youtube.com other demos i did while working on features: youtube.com youtube.com youtube.com youtube.com Would love to hear what you think, especially if you're already using Strudel or Tidal for live sets. With Love - Undy

Another release of Vibrance, to further improve quality. In the attached example, v0.2 is on the left, and v0.3 on the right. The yellow-blue gradient has recovered its contrast and saturation, and the white-blue gradient is smoother. github.com/romainguy/vibrance/releases/tag/v0.3.0

Building an In-Memory Circuit Breaker for Webhook Ingress: Shedding Load Without Losing Events Webhooks connect cloud systems. Payment providers like Stripe, code hosts like GitHub and commerce platforms like Shopify all use them to tell your services that something changed. When a sender has a bad day, you pay for it. A bulk export, a backfill or a burst of retries can hit your ingress endpoint, and the endpoint is the first thing that fails. When a burst arrives, worker threads or goroutines block on slow downstream calls and connection pools saturate. Memory fills with queued request bodies and garbage-collection pressure pushes latency higher. Health checks start failing, the load balancer moves traffic to the remaining nodes, and those nodes tip over too. This guide describes an in-memory admission controller for webhook ingress. It combines an adaptive concurrency limit, a CoDel-style delay signal and priority-aware shedding. It also covers what “not losing events” means when you reject a request, because that depends on how each sender retries. 1. How an ingress meltdown unfolds Webhook senders enforce short response deadlines, and each provider sets its own: | Sender | Documented behavior | | --- | --- | | GitHub | Expects a 2XX within 10 seconds, otherwise it terminates the connection and counts a failed delivery. It does not redeliver automatically; failed deliveries must be redelivered manually or via the API. | | Shopify | One-second connection timeout and five-second timeout for the whole request. Failed deliveries are retried 8 times over 4 hours. | | Slack (Events API) | Expects a valid response within three seconds. | | Stripe (live mode) | Retries for up to 3 days with exponential backoff. | Because the deadlines are short, a slow endpoint produces timeouts, and timeouts produce more traffic. A sender that retries adds those retries to the stream of fresh events. A sender that doesn’t retry, like GitHub, leaves you with lost events and manual redelivery. The failure then plays out in a predictable order: 1. Connection saturation: new connections queue in the socket backlog. 2. Worker starvation: handlers blocked on database calls hold their threads or goroutines. 3. Memory growth: request bodies pile up while waiting for a worker. 4. Latency amplification: garbage-collection work and contention raise latency, which causes more sender timeouts. [Upstream Sender] ──(flood / retries)──> [Load Balancer] │ ▼ [Ingress Worker Node] ├── Connection queue (full) ├── Workers (blocked) └── Memory / GC (pressure) ──> [meltdown] The first defense is architectural. GitHub’s documentation recommends putting a queue in front of slow work so the server can respond immediately and process the payload in the background. Shopify gives the same advice for bursts. Admission control is the second line of defense. It protects the thin “validate, enqueue, acknowledge” path itself. 2. Why the admission decision should be local Resilience4j’s circuit breaker is the standard tool for outbound calls. It is an in-process library and doesn’t need Redis or any other shared store. The same reasoning applies at ingress: - No extra dependency on the hot path. Consulting a shared store for every inbound request adds a network round trip and a new failure mode. If that store is down, your ingress should still be able to shed load. - The overload is local. Thread pools, memory and database connections are per-node resources. A node-local signal reflects what that node can actually handle. - Senders only see HTTP. They react to status codes and timing, so the cleanest signal you can give them is a fast, explicit rejection. The trade-off is that each node decides independently. With uneven load balancing, one node may shed while another has spare capacity. Per-node metrics (section 7) show you when that happens. 3. Two mechanisms: adaptive concurrency and queue delay Adaptive concurrency limits Little’s Law says that concurrency equals throughput times latency. A fixed limit such as “100 concurrent requests” goes stale as soon as latency changes. If the database slows down, 100 is too high. If it speeds up, 100 is too low. Netflix’s open-source concurrency-limits library, described in their 2018 post “Performance Under Load”, adjusts the limit from observed latency instead. Its gradient algorithm uses: newLimit = gradient × currentLimit + queueSize In the library’s Gradient2 variant, the gradient is the long-term RTT divided by the current RTT, clamped to the range 0.5 to 1.0. The result is then smoothed (default factor 0.2): gradient = max(0.5, min(1.0, longTermRTT / currentRTT)) newLimit = gradient × currentLimit + queueSize newLimit = currentLimit × (1 − smoothing) + newLimit × smoothing When latency rises above its long-term average, the gradient drops below 1 and the limit shrinks. When latency is stable, the queueSize term lets the limit creep upward. It can be a fixed value or a function of the limit, such as a square root. Queue delay (CoDel-style) Counting 5xx errors reacts late, because by the time errors appear the damage is done. A better early signal is how long requests wait for a slot. CoDel (Controlled Delay) was designed by Kathleen Nichols and Van Jacobson as an active queue management algorithm for network buffers (RFC 8289). It tracks a packet’s sojourn time, the time spent in the queue. It acts only when the minimum delay over a sliding window stays above a target, which allows short bursts but prevents a persistent standing queue. RFC 8289’s defaults are a 5 ms target and a 100 ms interval. Facebook adapted a variant of CoDel for request queues, as described in “Fail at Scale”. Its open-source Wangle library shows the idea. Within each interval it tracks the minimum queueing delay and declares overload if that minimum exceeded the target. While overloaded, it sheds requests that have waited longer than twice the target. This is an adaptation rather than textbook CoDel. Treat 5 ms and 100 ms as starting points and tune them against your handler’s normal service time. 4. Architecture Requests pass through classification and then a limiter that both enforces the adaptive limit and measures queue delay: Incoming webhook request │ ▼ ┌──────────────────────────────────────────┐ │ 1. Priority classifier │ │ (route or verified partner identity) │ └──────────────────────────────────────────┘ │ ▼ ┌──────────────────────────────────────────┐ │ 2. Admission: slot free? │ │ yes → admit; no → queue briefly, or │ │ shed if overloaded (by priority) │ └──────────────────────────────────────────┘ │ (slot acquired) ▼ ┌──────────────────────────────────────────┐ │ 3. Thin handler: verify signature, │ │ enqueue durably, return 2xx │ └──────────────────────────────────────────┘ │ ▼ Release slot → feed RTT back to the limit Classify by something you control, such as the endpoint path or the partner identified after signature verification. Don’t trust a priority header that arrives from the public internet, because anyone can set it. 5. A working Go sketch The following sketch uses only the standard library. It combines a Gradient2-style limit with a Wangle-style overload flag. The parameter values are illustrative and need tuning against your own traffic. package ingress import ( "math" "net/http" "sync" "time" ) type Priority int const ( PriorityLow Priority = iota PriorityDefault PriorityHigh ) type Config struct { InitialLimit float64 // e.g. 20 MinLimit float64 // e.g. 4 MaxLimit float64 // e.g. 200 Smoothing float64 // e.g. 0.2 TargetDelay time.Duration // e.g. 5ms Interval time.Duration // e.g. 100ms MaxWait time.Duration // longest a request may wait for a slot, e.g. 2 * TargetDelay MaxQueue int // hard cap on waiting requests } type waiter struct { ready chan struct{} granted bool } type Limiter struct { cfg Config mu sync.Mutex limit float64 inflight int waiters []*waiter shortRTT float64 // seconds, fast EWMA longRTT float64 // seconds, slow EWMA intervalEnd time.Time minDelay time.Duration overloaded bool } func NewLimiter(cfg Config) *Limiter { return &Limiter{cfg: cfg, limit: cfg.InitialLimit} } // Acquire returns a release func and true if the request is admitted. func (l *Limiter) Acquire(p Priority) (func(time.Duration), bool) { l.mu.Lock() if l.inflight < int(l.limit) && len(l.waiters) == 0 { l.inflight++ l.observeDelay(0) l.mu.Unlock() return l.release, true } if l.shouldShed(p) { l.mu.Unlock() return nil, false } w := &waiter{ready: make(chan struct{})} l.waiters = append(l.waiters, w) l.mu.Unlock() start := time.Now() timer := time.NewTimer(l.cfg.MaxWait) defer timer.Stop() timedOut := false select { case <-w.ready: case <-timer.C: timedOut = true } l.mu.Lock() defer l.mu.Unlock() l.observeDelay(time.Since(start)) if timedOut && !w.granted { l.removeWaiter(w) return nil, false } return l.release, true } func (l *Limiter) shouldShed(p Priority) bool { switch p { case PriorityHigh: return len(l.waiters) >= l.cfg.MaxQueue // only when the queue is full case PriorityDefault: return l.overloaded || len(l.waiters) >= l.cfg.MaxQueue default: // PriorityLow: no queueing at all once slots are exhausted return true } } // observeDelay tracks the minimum queueing delay per interval (CoDel-style). func (l *Limiter) observeDelay(d time.Duration) { now := time.Now() if now.After(l.intervalEnd) { l.overloaded = l.minDelay > l.cfg.TargetDelay l.minDelay = d l.intervalEnd = now.Add(l.cfg.Interval) return } if d < l.minDelay { l.minDelay = d } } func (l *Limiter) release(rtt time.Duration) { l.mu.Lock() defer l.mu.Unlock() l.inflight-- l.updateLimit(rtt.Seconds()) for len(l.waiters) > 0 && l.inflight < int(l.limit) { w := l.waiters[0] l.waiters = l.waiters[1:] w.granted = true l.inflight++ close(w.ready) } } // updateLimit is a simplified Gradient2-style update. func (l *Limiter) updateLimit(rtt float64) { if rtt <= 0 { return } if l.longRTT == 0 { l.longRTT, l.shortRTT = rtt, rtt } l.shortRTT += 0.2 * (rtt - l.shortRTT) l.longRTT += 0.01 * (rtt - l.longRTT) gradient := math.Max(0.5, math.Min(1.0, l.longRTT/l.shortRTT)) next := gradient*l.limit + math.Sqrt(l.limit) next = l.limit*(1-l.cfg.Smoothing) + next*l.cfg.Smoothing l.limit = math.Max(l.cfg.MinLimit, math.Min(l.cfg.MaxLimit, next)) } func (l *Limiter) removeWaiter(w *waiter) { for i, x := range l.waiters { if x == w { l.waiters = append(l.waiters[:i], l.waiters[i+1:]...) return } } } // Guard wraps a webhook handler with admission control. func Guard(l *Limiter, classify func(*http.Request) Priority, next http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { release, ok := l.Acquire(classify(r)) if !ok { w.Header().Set("Retry-After", "10") http.Error(w, "service temporarily overloaded", http.StatusServiceUnavailable) return } start := time.Now() defer func() { release(time.Since(start)) }() next.ServeHTTP(w, r) }) } Some limits of this sketch: - Waiters are served in FIFO order. Facebook’s design switches to LIFO once a queue forms, so the newest requests, which are most likely to still meet their sender’s deadline, go first. - RTT is measured for every request. In production you would typically exclude requests that failed fast. - A single mutex is fine at moderate rates. Profile before optimizing it. 6. Rejecting requests without losing events Whether a rejected webhook is lost depends on the sender, so you need to know how each one behaves: - Senders with retries: Stripe retries with exponential backoff for up to 3 days in live mode. Shopify retries 8 times over 4 hours. - Senders without automatic retries: GitHub does not redeliver automatically. If you shed a GitHub delivery, you need to redeliver it manually or through the API once you recover. - Subscription risk: Shopify deletes a webhook subscription created through the Admin API after 8 consecutive failures, and Stripe emails you and eventually disables an endpoint that fails for multiple days. A long shedding episode can cost you the subscription itself. For these reasons, shedding should be short, targeted and backed by a reconciliation job. Shopify itself recommends building one if you can’t afford to miss webhooks. The job periodically fetches data you may have missed through the provider’s API. Status codes - 503 Service Unavailable with Retry-After: the standard way to signal temporary overload. RFC 9110 defines Retry-After as either a number of seconds or an HTTP date. - 429 Too Many Requests: RFC 6585 defines it for rate violations by a particular sender. It also accepts Retry-After. - Don’t just drop connections. An abrupt reset gives the sender no information, and it will treat the delivery as a failed attempt. A clean 503 tells it explicitly that the failure is temporary. Do senders actually honor Retry-After? Some do. Webhook infrastructure vendors such as Hookdeck and Kit document that they respect Retry-After on 429 and 503, and AWS EventBridge API destinations are documented to as well. Svix advises that good senders will respect it when you return a 429. Stripe’s public documentation describes exponential backoff but doesn’t mention Retry-After, so check its behavior in your delivery logs rather than assuming. Because support varies, treat the header as a hint and rely on the sender’s own backoff as the fallback. Add jitter to the values you return, for example 5 to 15 seconds instead of a constant 10. Otherwise senders that honor the header will retry in lockstep. 7. Priority-based shedding Not all webhooks are equally urgent. A payment confirmation matters more than a bulk analytics sync. Classify by endpoint or authenticated partner, then apply different behavior per tier. The sketch above implements this policy: | Tier | Examples | Behavior in the sketch | | --- | --- | --- | | PriorityHigh | Payment confirmations, security alerts | Queue for a slot; shed only when the wait queue is full. | | PriorityDefault | Standard operational updates | Queue, but shed once the CoDel-style overload flag is set. | | PriorityLow | Bulk syncs, analytics, non-essential notifications | Shed immediately when no slot is free. | This is a policy choice rather than a standard. Choose tiers based on which events you can safely replay later. 8. Observability Since each node decides for itself, you need per-node metrics. Export them to Prometheus or OpenTelemetry: 1. webhook_ingress_concurrency_limit: gauge for the current adaptive limit. 2. webhook_ingress_inflight_requests: gauge for requests being processed. 3. webhook_ingress_shed_total{priority}: counter of rejected requests. 4. webhook_ingress_queue_delay_seconds: histogram of time spent waiting for a slot. Use millisecond-scale buckets, since the targets are in the single-digit-millisecond range. 5. webhook_ingress_overloaded: gauge (0 or 1) for the overload flag. Alert on a sustained rise in shed counts or on queue delay staying above target. Both mean you should look at downstream capacity, not just the limiter. 9. Checklist - Acknowledge fast: Verify the signature, enqueue durably and return 2xx. Do the real work asynchronously. - Keep admission state local: Avoid a shared-store call on every inbound request. - Use a latency-driven limit: An adaptive, gradient-style limit beats a fixed number. - Watch queue delay, not just errors: Use a CoDel-style minimum-delay signal, and tune the target to your handler. - Reject explicitly: Return 503 (or 429 for per-sender limits) with a jittered Retry-After. - Know your senders: Document each provider’s timeout, retry window and subscription-deletion rules. - Reconcile: Run a job that backfills events missed during shedding, and redeliver GitHub deliveries manually. - Classify safely: Derive priority from routes or verified identity, never from unauthenticated headers. References - Stripe webhooks documentation: <docs.stripe.com> - GitHub, “Best practices for using webhooks”: <docs.github.com> - Shopify, “Deliver webhooks through HTTPS”: <shopify.dev> - Slack Events API response deadline: <vincentschmalbach.com> - Netflix Technology Blog, “Performance Under Load”: <netflixtechblog.medium.com> - Netflix concurrency-limits library: <Netflix/concurrency-limits> - RFC 8289, “Controlled Delay Active Queue Management”: <datatracker.ietf.org> - CoDel pseudocode (ACM Queue): <queue.acm.org> - Facebook Wangle CoDel implementation: <github.com/facebook/wangle/blob/master/wangle/con…> - Svix, “Webhook retry strategies”: <svix.com> - Hookdeck, “Webhook Delivery Guarantees”: <hookdeck.com> --- Originally published at instawebhook.com

Why I keep ASR errors, translation errors and timing errors separate in a subtitle pipeline I'm a former professional translator/subtitler/interpreter and the developer of Subtitle Foundry. One design decision in the project is to keep transcription, translation and timing separately inspectable. Here's why that matters even when the pipeline uses state-of-the-art (SOTA) speech and language tools. A fluent final sentence can hide where an error entered. For a hypothetical example, suppose the spoken line is “he didn't go,” but ASR drops the negation. A translation model might use the surrounding dialogue to recover the intended meaning, or it might confidently translate the wrong statement. Reading only the final subtitle won't establish which happened. This is an illustrative example, not a measured result from my films. That leads to three different checks: - Transcription: compare the recognized source words against the audio. Keep raw ASR output available even if a later stage improves the displayed text. - Translation: compare the target meaning against the source audio/corrected transcript and dialogue context. A fluent rewrite is not sufficient evidence that an apparent ASR correction was justified. - Timing and readability: listen while watching the cue boundaries, speaker changes, line breaks and display duration. Correct words can still make poor subtitles when shown at the wrong time. Timing evidence also needs a label. My default route uses ElevenLabs Scribe v2's native word timestamps on the complete recording. Other supported workflows use chunks and optional speech-activity alignment. Speech activity tells you where speech occurs; it does not by itself locate each word. Treating estimated timing as equivalent to provider word timing makes later review harder. Keep source evidence when changing the target-language cues. The app has an exact-timing mode for existing subtitles and an editorial mode that forms target-language cues from source words and speaker turns. This allows different sentence structure in the translation while retaining evidence for where the dialogue belongs. Both workflows end in video/waveform review, with saved manual corrections. Evaluate stages before comparing a final file. For a useful comparison, I would keep the same audio excerpts, corrected source reference and source offsets across providers; record model/settings; then assess source transcription, translated meaning and cue timing separately. Aggregate word-error rates alone don't measure translation quality or subtitle readability. Intermediate artifacts and cached provider responses also make it easier to inspect one stage without paying to regenerate every other stage. My film testing so far has mainly been Turkish-to-English and Ukrainian-to-English with ElevenLabs plus Codex. I haven't published a controlled end-to-end benchmark, so these are implementation choices and an evaluation approach, not a performance ranking. Source and workflow documentation: mrtdlgc/subtitle-foundry I'm not making money from this AGPL-3.0 project, and I'll keep maintaining it. The purpose is to help material that lacks usable subtitles reach a global audience. I used Codex during development, and this write-up was prepared with Codex assistance.

DiscImageStudio: burn visible artwork onto CDs, DVDs and Blu-ray discs JiaFeiMiao-K-Cat/DiscImageStudio