Mentions

极速 HDR 图片转换器，广色域多格式输出，支持手机的 HDR 照片, JXR 游戏截图, RAW 普通的图片工具对的 HDR 格式支持度一般，设计软件又太笨重了， 用 LocalViewer 开源的图片处理代码做了个 Qt 跨平台的图片转换工具， 支持安卓苹果相机的 gain map 照片，Win11 的游戏截图，也支持相机的 RAW 文件转成浏览器支持的真 HDR. PS: 鉴于图片工具的复杂性，做下自我介绍。我是正版 DaVinci Resolve Studio, Calman, ColourSpace 用户，不是一句话生成 APP. 下载地址 JXRConverter 图片转换 zmz125000/JXRConverter LocalViewer 安卓看图神器 zmz125000/LocalViewer 功能 1. 转换 JXR, JXL, RAW 格式到浏览器和手机支持的 JPG/AVIF gain map (Ultra HDR/ISO 21496-1) 和 AVIF/JXL PQ HDR. 2. 转换压缩手机 HDR 图片 JPEG/HEIF/AVIF 到 JPEG/AVIF gain map. 3. 自动色彩管理，保留广色域，高色深，ICC, Exif 信息。 4. 准确的 JXR 和 RAW 格式转换流程，RAW 支持 HDR Boost 处理。 7. 超快的图片缩略图, SSD 下瞬间加载 4K JXR 格式。 6. 采用 Float32 高精度图片处理。 7. 支持 Windows, MacOS, Linux. 格式支持 | Input | Output | Processing | |-------------------------------------------|----------------------------------------------------------------------|-------------------------------| | SDR | SDR JPEG, AVIF or JXL | 图片压缩, 保留广色域和高位深 | | HDR gain-map photos | Gain-map JPEG or AVIF | 图片压缩, 保留 gain map, 广色域和高位深 | | HDR images (PQ/HLG AVIF, PNG or JXL) | SDR; gain-map; linear or PQ | 解码到 float32, 转换输出 HDR | | Linear HDR and scRGB (JXL, scRGB JPEG XR) | Linear JXL, scRGB JXL, PQ JXL/AVIF | 解码到 float32, 转换输出 HDR | | Camera RAW | SDR JPEG/AVIF/JXL; gain-map JPEG/AVIF; linear/scRGB JXL; PQ JXL/AVIF | 解码到 float32, HDR 渲染，转换输出 HDR |  JPEG XR 样图  |  |  | |-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| RAW HDR BOOST 样图 原图来自 rawsamples.ch 

I built it. Try it out here: technophile77/to-dream

@SirToastyToes I used this but I understand it isn’t for everybody: zaksabeast/XY-All-Friend-Safaris-Patch

@dodeja @useblacksmith @boatdotdev We had the same problem. Made this little ci broker that lets use spot VMs from GCP. Try it out! benandbalto/also-ran

@SehmatRT @maxvonhippel @chaaai @miike For floats may be worth looking into leandojo.org or opencompl/fp-lean.

An AI agent that catches when another agent is lying. Assure: • Your AI agent says done. This checks if it is lying • Cross-checks claims against sources • Verifies agent output before it ships Trust, but verify with an AI agent. mgasparin67-cmd/Agent-verification_Assure

啊啊啊😮😮！这破项目才不到150 star，还收到了一些邀请，珀莱雅举办的AI比赛？？ 这...靠谱吗？有没有懂的呀？ YeJe-cpu/easy-jianying t.co

LinQuant: Functional Invariances for Low-Precision Linear Recurrences Neehal Tumma, Philipp Nazari, Rohan Cherukuri, Daniela Rus, T. Konstantin Rusch arxiv.org [𝚌𝚜.𝙻𝙶] 💬Code: ntumm120/LinQuant t.co

@HashgraphOnline @REL Done — PR is up: hol-guard#7049 ⚡ Added @rel-time/mcp-server (mcp.rel-time) + the external trust binding: • Review on credit-spending, key-provisioning & file-stamping tools (reltime_anchor_file, reltime_anchor_hash, reltime_provision_agent_key, reltime_link_passkey, reltime_stamp_file) • Inherit on Sun-Stamp SVG fetches, Bitcoin proof verification & Superhighway forensic audits (reltime_get_sun_stamp, reltime_check_proof, reltime_account_status, reltime_audit_trail) Pre-execution policy gate (HOL Guard) + post-execution VDF & Bitcoin settlement proof (Rel-Time) is a killer stack for autonomous agents. Appreciate the fast look! 🤝

Mixify 1.0.7 — an open-source Android music app with a refreshed UI, synced lyrics and Listen Togethe Hi r/foss! I maintain Mixify, a free, open-source Android music app, and wanted to share the work on version 1.0.7. This update refreshes the Home screen, player, Explore, Library and playlists. It also improves sharing previews and updates the Settings and About screens. Mixify includes: • Synced lyrics and Cinema Mode • Offline playback for downloaded music • Listen Together rooms for listening with friends • Song, playlist and lyrics sharing • An optional anonymous Listening Now counter, disabled by default For transparency, Mixify 1.0.7 is based on BitChord 1.9. Credit goes to its developer and the upstream projects acknowledged in our README. Mixify is licensed under GPL-3.0. I've attached screenshots of the updated interface. I'd love feedback on the layout, readability and anything that feels awkward to use. Source code: MixifyTeam/Mixify APK downloads: github.com/MixifyTeam/Mixify/releases/latest Website: mixify.co.in I'm the maintainer, so happy to answer questions and hear suggestions!

Country flags for the native UI of #mygo apps. @localhost_4173 xiyaowong/flagicons

EADDRINUSE again? This tool tells you who owns the port before you kill anything EADDRINUSE again? This tool tells you who owns the port before you kill anything > port-reclaim finds the process holding a busy dev port, shows you what it is, reclaims it when it's obviously yours, asks when it isn't, and refuses when it would be a mistake. !port-reclaim freeing a port, declining to kill a database, and refusing a Docker process | | | |---|---| | Try it now | npx port-reclaim 3000 | | Platforms | macOS · Linux · Windows · WSL2 (PowerShell + CMD) | | Requires | Node.js 18+ | | Runtime deps | 1 | | Package size | ~21 KB | | Telemetry | none — no network calls, nothing stored | | License | MIT | Why this exists Error: listen EADDRINUSE: address already in use :::3000 The reflex is lsof -i :3000 → read a PID → kill -9 it. Three things go wrong with that: 1. -9 skips graceful shutdown — anything mid-write to a socket, DB, or temp file gets truncated. 2. You're typing a number you read off a screen into a destructive command — TCP and UDP both appear, PIDs repeat, and fatigue picks the wrong one. 3. A PID is not a decision. "Something is on 3000" ≠ "that's the dev server you orphaned 40 minutes ago, not the Postgres." The one check that fixes it port-reclaim compares the working directory of the process with the directory you're standing in. $ port-reclaim 3000 --list Port 3000 is used by 'node' (PID 21836, '~/project', up 42m 11s) — matches the current directory. $ port-reclaim 3000 Released port 3000 from node (PID 21836). | Situation | What happens | |---|---| | Process started from your directory | Reclaimed silently — graceful signal first, forceful only if it survives | | Different directory, or CWD unreadable | Shows name, PID, path, uptime — asks you | | Docker, HTTP.sys, systemd | Refuses, even with --yes | | A database | Always asks, even if it shares your directory | | Owner invisible to your user | Reports it as unclaimable instead of "free" | | Windows process, you're in WSL2 | Names it, and explains why Linux can't see it | $ port-reclaim 5432 Port 5432 is used by 'postgres' (PID 3352, '~/dbdata', up 3h 12m). Kill it? (y/N) What it refuses to touch The refusals are the point. They exist because the easy version of this tool is 20 lines of shell. > Docker & the kernel are off-limits. > Port 8080 is used by 'docker-proxy' (PID 16004, …). Refusing to kill it — it appears to be a Docker process — stop the container instead (for example 'docker stop <container>'). Killing docker-proxy doesn't stop your container, it just leaves Compose in a worse state. PIDs 0–4 are protected on the same logic: System/HTTP.sys on Windows, systemd on Linux. --yes cannot override either. > Databases never die quietly. postgres, postmaster, mysqld, mariadbd, mongod, redis-server, memcached, etcd always confirm — even when running from inside your project, which is exactly the case a same-directory shortcut gets catastrophically wrong. > "I found nothing" is not "the port is free." When the owner is another user's or an elevated process, lsof returns nothing — and empty output looks identical to a free port. So the tool checks the answer by briefly binding the port: > Port 3000 is in use by a process port-reclaim cannot see — it may belong to another user, an elevated process, or a socket still closing. > It exits 1, so port-reclaim 3000 && next dev fails loudly instead of succeeding at nothing. > WSL2 tells the truth. Under default NAT networking, Linux and Windows have separate port spaces, so a Windows-held port looks free to every Linux tool — including this one until I tested it. It reaches across and says: > Port 4951 is free inside WSL, but a Windows tcp listener 'node.exe' (PID 19220) already holds it. > It reports rather than acts: a Windows PID passed to process.kill() would signal an unrelated Linux process. Made for scripts port-reclaim 3000 5173 8080 # several ports port-reclaim --match '^node$' # every port held by a matching process name port-reclaim --json # machine-readable, never terminates port-reclaim # ports from config, no arguments { "port-reclaim": { "ports": [3000, 5173], "ignore": [5432] } } A .reclaimignore file protects ports absolutely — that beats every heuristic. --list inspects without acting. Exit codes: 0 free or released, 1 still in use, 2 bad input. Colour turns itself off when output isn't a terminal (--no-color, NO_COLOR, FORCE_COLOR all respected — that's how the GIF above was recorded). There's a programmatic API too: discover, discoverListening, terminate, probe. Fast, and measured Whole-command wall clock on Windows 11 under Node 24, including Node's own startup, because that's the part people leave out of benchmarks: | | before | now | |---|---|---| | answer "is port 3000 free?" | ~1.00s | ~0.10s | | identify what's on a busy port | ~1.26s | ~0.41s | | full reclaim of one process | — | ~0.59s | The "before" was a bug: discovery started PowerShell three times per port, and a cold powershell.exe costs ~0.7s. Now netstat decides whether anything is on the port, and PowerShell starts at most once, to name the processes actually found. The honest limits - Not a process manager or supervisor, and no substitute for docker compose down. - UDP matching is a heuristic — a UDP socket on a port can belong to a client, not a server. - The free-port check binds momentarily, so a connection arriving in that instant can read as "in use". A race, not a flaw I'll paper over. - It can't see other users' processes without your own elevated privileges. - 0.x, one maintainer, ~52 tests across macOS/Linux/Windows × Node 18/20/22/24. The programmatic API may still move — read the changelog before upgrading. Five real bugs are documented in that changelog — a taskkill missing /F that reported success while the port stayed busy, a PowerShell cmdlet name that never existed, an uptime calculation always negative on Windows, process names silently wrong on macOS and Node 24 (which quietly disabled the protections above), and a WSL check that once blamed WSL's own relay process. All five are now covered by tests that bind a real socket and make the tool find it through the actual OS. Get it npx port-reclaim 3000 # or npm install --global port-reclaim npm → port-reclaim · source → princegoel0/port-reclaim If it saves you one bad kill -9, it did its job. OS quirks I haven't hit are exactly what I want an issue about.

> CamMonitor 是一款开源安卓应用，能把你的闲置旧手机变成一台免注册、免云端的点对点（P2P）加密家庭监控摄像头，用日常手机随时查看实时画面。 作者表示，它要把闲置手机变成一台私人家庭监控摄像头，不用账号、不用云订阅、不用第三方服务器存你的视频。 samlu/CamMonitor

@yetone 许愿修一下 MAGPIE 的大请求慢上传超时🙏 长对话/图片还在上传，2 分钟就被截断，尚未进入供应商路由。最新版 v0.1.2791 仍有这个限制。已在 issue 补充实测、修复分支和回归结果，盼合入～ magpie#4775

@neeraj_here15 I built it exactly as she described: technophile77/to-dream

実験の記録一式はGitHubで公開されています RikiyaT/lm_understand-logs

정말 좋은 영상인데.. 100분 영어 강의는 부담스러우시죠? playback-notes 스킬 써서 한국어 요약본으로 만들어서 보세요!! /playback-notes <x 링크> 한국어로 요약해줘 AgwaB/playback-notes t.co

AgentTM – A time-travel debugger for AI coding agents, built with Go I've been building AgentTM, a local-first developer tool written primarily in Go that records Codex execution history and allows developers to inspect and restore previous workspace states. The current v0.1 implementation includes SQLite-backed event storage, SHA-256 content-addressable snapshots, historical file inspection, code diffs, and isolated checkpoint restoration using Git worktrees. It also includes a React/TypeScript dashboard, with the frontend embedded into the Go binary. Currently, it only captures non-interactive Codex sessions launched through AgentTM. I've tested the end-to-end workflow on Windows, including checkpoint restoration and cancellation handling. Native Linux/macOS testing and broader agent support are still pending. The long-term goal is to support multiple coding agents and allow developers to inspect, rewind, and branch their execution histories. Sharing the current implementation for anyone interested in Go-based developer tooling and agent observability. Repository: Jyotishmoy12/AgentTM

Nice! Can you add a message saying it doesn't work on browsers that don't support it? You can also support using SmolLM2-360M-Instruct as fallback for those browsers. I made mkornreich/browser_llm to get that logic working if you want to use it.

I have vibe coded this. For you guys to use. kryptoxerk-dot/kaiba-ultimate-agent-public All things crypto, automated

@climente_alin @marcelotryle The Python docs show a worker running as an asyncio task, followed by shutdown() and awaiting completion. That looks adaptable to lifespan, though I haven't tested the FastAPI integration. Shutdown gets a grace period. github.com/Kludex/pgtask/blob/main/docs/sdk/pytho…

这个项目和我想一块了 用飞书来控制herdr 一个话题一个session 终端在手上 输入全靠嘴 快来试试吧 Yaron9/feishu-terminal

XMTP, the encrypted messaging protocol behind Coinbase and World chat, now runs its coding agents inside @Docker Sandboxes. One sbxenv.yaml file sets it up: 🔹 Claude Code + Codex kits 🔹 No host mounts, no open ports 🔹 API keys stay on the host xmtp/libxmtp

Open source tool for running an onion site with DDoS and bot protection that works with JavaScript off Anyone who has run an onion site knows the problem: once it gets any traffic, bots and floods show up, and the usual protections don’t work here. Cloudflare-style tools rely on seeing the visitor’s IP, country and browser fingerprint, and on JavaScript running. An onion service gets none of that, and a lot of visitors have Tor Browser set to Safest. I’ve been building onyums to deal with this. It’s a Rust library for hosting an onion site, with Tor (Arti) built in, so there’s no separate tor process or torrc to set up. The protection layer, onyums-skin, works like this: - Visitors with JavaScript on get a small proof-of-work puzzle that their browser solves in the background - Visitors with JavaScript off get a simple CAPTCHA, rendered on the server, with a text-only option - If neither works, the request is slowed down rather than refused, so nobody is locked out completely - A visitor who passes gets a signed token, and rate limits are tracked per token, not per IP - There’s a WAF in front of the site, and an “under attack” mode that makes the puzzles harder while a flood is going on None of it uses or needs client IPs, and none of it loads anything from a third party. It won’t stop a determined attacker. The goal is to make flooding the site cost more than it costs you to serve it. It doesn’t yet defend against floods at the introduction-point level (Tor’s built-in Equi-X proof of work). That’s the next thing I’m adding. After that: - Moving an existing onion site to onyums and keeping its .onion address - A command line tool for putting a site you already run (nginx, a forum, anything local) behind an onion address with this protection in front, without writing any code For now you need to know a bit of Rust to use it. That’s what the command line tool is meant to fix. If you run an onion site, I’d like to know what attacks you see most often and what you’re using against them now. Code (MIT): basic-automation/onyums Website: basicautomation.io

V1.0 release of Super Mario World running natively on the DS Lite, dual screen port **Code generated by Claude Opus 5.5.** I used Claude to make a native, dual screen port of Super Mario World (SNES) for the Nintendo DS. It is not an emulator, the game's logic runs as native ARM code (built on snesrev's open-source C reimplementation of SMW), and the picture is drawn by the DS's own 2D hardware. ***************MARIO RUNNING BACKWARDS ON BOTTOM SCREEN BUG FIXED*************** What works: - The whole game, start to finish: every level, secret exit, castle, Mode 7 boss, cutscene and the ending - Full speed (60 fps) on a real DS Lite with an R4, with the game's music and sound effects (echo included) - Saving to the microSD card Testing: on my DS Lite I've played levels, castles with their boss fights and cutscenes, saving, and the ending credits. Every level, map and cutscene was also checked frame by frame against a reference render of the original game. A few tiny visual differences are listed in the README. The bottom screen: - A background that changes with where you are, example, the world map, or the level's setting (grass, sky, cave, underwater, castle over lava, ghost house, forest, ice, Star Road, switch palaces, Chocolate Island) - The level name, plus big lives, coins, time and score counters - A big reserve-item box: tap it to drop your stored item - Mario walking toward the goal posts as you progress through the level - An FPS counter (tap to hide) The top screen uses a smart camera, due to the DS screen being 32 lines shorter than the SNES picture. **GitHub (download + instructions):** jixovin/super-mario-world-nds **NO GAME DATA IS INCLUDED.** You need your own Super Mario World (USA) ROM. Works on Windows, macOS and Linux. Credits: snesrev (SMW C reimplementation)

Open Duet 开源了自托管 AI 同事团队 命名 agent 带记忆和例行任务 有隔离电脑 动手前要你批准 对标 Claude Duet / OpenAI Dots 自己管密钥和机器 你更想等官方开放 还是先自建一套 Anil-matcha/open-duet t.co

I built an open-source Dynamic Island for Windows 10 & 11 in pure Python (<18 MB RAM, zero Electron, native Win32 SMTC media controls) Hey everyone! I love the concept of ambient HUDs, but most third-party desktop widgets for Windows either run on Electron (eating 300+ MB RAM in the background) or come bundled with bloated telemetry and forced upselling. I decided to build Dynamic Island for Windows from scratch in lightweight Python: - < 18 MB RAM Footprint: Built using CustomTkinter with Win32 ctypes bindings. Zero Chromium runtime. - Native SMTC Media Controls: Hooks directly into Windows System Media Transport Controls to display Spotify, browser playback, and system volume with live track info and progress bars. - Per-Monitor DPI Awareness: Handles mixed-scale multi-monitor setups (100% to 200%) dynamically without blurry scaling or window clipping. - Smart Fullscreen Detection: Detects focused fullscreen applications/games per display and silently yields without stealing window focus (SWP_NOACTIVATE). - Single-File Plugin Architecture: Extend with custom widgets (timers, weather, price radars) by dropping a Python script into /plugins. Video demo in action: youtube.com The code is 100% free and open-source: RanuK12/dynamic-island-win Would love to hear your thoughts on edge cases or widgets you would find useful!

RoamRun 0.12.0 をリリースしました。 ・CI のビルドを Mac の OTA ページに公開できるようになりました（GitHub Actions / Bitrise / Xcode Cloud で確認） ・Apple TV に対応。離れた場所の Mac の Xcode から、Apple TV でアプリを実行・デバッグできます github.com/mh-mobile/RoamRun/releases/tag/v0.12.0

It's open source (AGPL) and free. You bring your own API key, or run a small model on the phone offline. The site in the video took 4m 02s and cost about $0.82 in API usage. springmusk026/locus APK on the Releases page. Feedback and stars welcome 🙏

平均エラー率が同じでも、AIの間違いが怖い理由をシミュレーションで確かめる はじめに：問題は「どれだけ」ではなく「どう」間違えるか 人は必ず間違えます。AIも必ず間違えます。ここまでは誰もが認めるところです。 それなのに、AIの導入の場面では「AIが一度間違えたから導入を見送る」という判断をよく見かけます。人間の担当者が同じくらい間違えていても、それで業務が止まることはありません。 心理学ではこの傾向をアルゴリズム回避（algorithm aversion）と呼びます。人はアルゴリズムが間違えるのを一度見ると、同程度に間違える人間よりも、アルゴリズムへの信頼を大きく下げるというものです（Dietvorst, Simmons & Massey, 2015）。 では、AIの間違いを怖がるのは単なる思い込みなのでしょうか。私は半分はそうで、半分は違うと考えています。平均エラー率が同じでも、AIは人間と「間違え方」が違うからです。 この記事では、その違いをシミュレーションで確かめます。結論を先に書きます。 平均エラー率が同じ5%でも、まとめて間違えるAIは「悪い日」の誤りが人間の約2.2倍になる 同じモデルのAIを2つ重ねた二重チェックは、人間2人の約5.7倍の誤りをすり抜けさせる AI単体が人間より優秀（エラー率2%）でも、2つのAIの誤りの相関が0.35を超えると、人間2人の二重チェックに負ける つまり、AIを評価するときに見るべきは平均エラー率ではありません。どう間違えるかであり、それに合わせてチェック体制を設計することが大切です。 コードはすべて公開しており、Docker があれば数秒で再現できます。 shisei-kbrg322/fallible-by-design 2つの誤りモデル 1日1,000件の判定を、10,000日分シミュレーションします。判定は「正しい／誤り」の二値とし、どの判定者も平均エラー率は5%にそろえます。違いは誤りのまとまり方だけです。 人間型：独立に間違える 各件が5%の確率で、ほかの件とは無関係に誤ります。1日の誤り件数は二項分布になり、だいたい50件前後に収まります。 うっかりミスのように、どの件で起きるか予測できず、ある程度ばらけて起きる誤りのイメージです。 AI型：まとめて間違える AIは特定の種類の入力が苦手、ということがよくあります。苦手な入力が多い日はたくさん間違え、少ない日はほとんど間違えません。 これを、その日のエラー率自体がゆらぐモデルで表します。日ごとのエラー率を平均5%のベータ分布から引き、その率で各件の誤りを決めます。1日の誤り件数はベータ二項分布になります。 ゆらぎの大きさは級内相関 \rho で表します。1日 N 件の誤り件数の分散は次のとおりです。 \mathrm{Var} = N p (1-p) \left[ 1 + (N-1)\rho \right] \rho = 0 なら人間型と同じ二項分布です。N = 1000 なので、\rho = 0.02 という小さな値でも分散は約21倍になります。 2人の判定者の相関 φ 二重チェックを調べるには、2人の判定者が「同じ件で間違えやすいかどうか」を決める必要があります。 ここでは、2人目の判定者を次のように作ります。 確率 \varphi で、1人目と同じ結果を写す（同じ件で同じように誤る） 残りは、同じエラー率で独立に引き直す こうすると、2人目の平均エラー率は1人目と同じまま、誤り同士の相関がちょうど \varphi になります。同じモデルのAIを2つ並べた状態は、\varphi が高いケースに当たります。 二重チェックのルール 2人の判定が食い違えば、見直して正しく処理されるとします。最終的に残る誤り（すり抜け）は、2人とも誤った件だけです。二値の判定なので、2人とも誤ったときは同じ誤答で一致してしまい、食い違いとして検出されません。 平均エラー率がともに q の2者のすり抜け率は、次の式になります。 P(\text{すり抜け}) = \varphi q + (1 - \varphi) q^2 \varphi = 0（独立）なら q^2 で、5%同士なら0.25%まで下がります。\varphi = 1（完全に同じ間違え方）なら q のままで、二重チェックの意味がなくなります。 実装と再現 判定者モデルの中心は、この数行です。 src/fallible/judges.py def simulate_errors(rng, spec, n_days, n_items): """1人の判定者の誤り行列 (n_days, n_items) と、日ごとのエラー率を返す。""" rates = daily_error_rates(rng, spec.p, spec.rho, n_days) errors = rng.random((n_days, n_items)) < rates[:, None] return errors, rates def correlated_with(rng, first_errors, rates, phi): """1人目の誤り行列と相関 phi を持つ2人目の誤り行列を作る。""" copy_mask = rng.random(first_errors.shape) < phi fresh = rng.random(first_errors.shape) < rates[:, None] return np.where(copy_mask, first_errors, fresh) 比較の公平性を保つために、「相関を入れても平均エラー率は変わらない」こと、「すり抜け率が理論式と一致する」ことをテストで確認しています。 再現の手順は次のとおりです。 git clone shisei-kbrg322/fallible-by-design cd fallible-by-design docker compose run --rm test # テスト docker compose run --rm sim # 実験を実行し、図とCSVを出力 乱数のシードは config.yaml で固定しているので、この記事の図と同じ結果になります。パラメータを変えて試すこともできます。 結果A：平均は同じでも、悪い日の大きさが違う 人間型と、AI型（\rho = 0.02）の日次誤り件数の分布を重ねました。 判定者 ρ 中央値 上位1%の悪い日 最悪の日 人間型の「上位1%」を超える日 人間型 0 50件 67件 78件 0.7% AI型 0.005 48件 94件 135件 14.8% AI型 0.02 43件 148件 235件 24.2% AI型 0.05 35件 233件 430件 26.6% 面白いのは、ふだんの日はAI型のほうが誤りが少ないことです（中央値43件）。それでいて、上位1%の悪い日は148件と、人間型の約2.2倍になります。人間型にとって100日に1度しかない悪い日の水準を、AI型は4日に1度ほど超えます。 「AIはだいたい優秀なのに、たまにひどく外す」という印象は、この分布の形から生まれていると考えられます。平均だけで比べれば同じでも、現場で記憶に残るのは悪い日です。AIの誤りを怖がる感覚は、ここに関しては合理的です。 結果B：同じAIを2回通しても、二重チェックはほとんど効かない 3つの組み合わせで二重チェックをしたときの、すり抜け件数を比べました。各判定者の平均エラー率はすべて5%です。 組み合わせ 誤りの相関 φ 1,000件あたりのすり抜け 悪い日（上位1%） 人間 + AI 0.0 2.5件 10件 人間 + 人間 0.1 7.2件 14件 AI + AI（同じモデル） 0.8 40.9件 122件 同じモデルのAI同士は同じ所で間違えるので、二重にしても5%の誤りのうち約8割がそのまま残ります。「AIに出力させて、別のAIにチェックさせる」構成は手軽ですが、同じモデルや似たモデルを使うなら、安心感ほどの効果はありません。 人間同士にも、同じ研修を受けた、同じ思い込みを持っているといった理由で、弱い相関（\varphi = 0.1）を置きました。そのため、間違える所がずれている「人間 + AI」が最も効く結果になっています。 ! 人間同士の相関を \varphi = 0 にすると、「人間 + 人間」と「人間 + AI」はどちらも2.5件で並びます。「人間 + AI が最も良い」という結果は、人間同士にも共通の盲点があるという仮定に依存しています（results/b_sensitivity.csv）。 結果C：AI単体が優秀でも、組み合わせで逆転する 最後に、AI単体のエラー率と2つのAIの誤りの相関を動かしました。AIを2つ重ねたときのすり抜けを、人間2人の二重チェックを基準（1倍）として比べています。 境界線より右上では、AI×2のほうが人間2人より多くすり抜けます。 AI単体のエラー率 人間2人と同等になるAI同士の相関 φ 1% 0.72 2% 0.35 3% 0.22 5% 0.10 エラー率2%と人間より優秀なAIでも、2つのAIの誤りの相関が0.35を超えると、人間2人の二重チェックに負けます。同じモデルを2回通すような構成（\varphi = 0.8）では、人間2人の約2.2倍すり抜けます。 単体の精度だけを見て「人間より優秀だから、AIを重ねればもっと安全」と考えると、判断を誤ることがあります。 設計への示唆：誤りのタイプに合わせてチェックを変える 3つの結果から、AIを含む業務のチェック体制について、次のことが言えます。 1. AIは平均ではなく、悪い日と誤りの偏りで評価する 平均エラー率が同じでも、リスクの大きさは違います。上位パーセンタイルの誤り件数や、入力の種類ごとの精度を測っておく必要があります。 2. 二重チェックの価値は「違う所で間違える」ことから生まれる 同じモデルの再実行や、同じプロンプトの別サンプルは、独立したチェックの代わりになりません。チェック役には、間違え方の違う判定者（人間、別系統のモデル、ルールベースの検証）を置きます。 3. チェックの方法を誤りのタイプに合わせる 人間のうっかりミスのような独立した誤りには、抜き取り検査やダブルチェックが効きます。AIのまとまった誤りには、入力の分布の変化を監視して、苦手な種類の入力が増えた日を検知する仕組みが効きます。 4. 人間同士のダブルチェックも万能ではない 人間にも共通の盲点があります。AIを組み合わせることで、それを崩せる余地があります。AIは人間の代わりではなく、人間と違う間違え方をする相棒として使うのが、最も効果的です。 限界と次回予告 この実験には、次の限界があります。 パラメータ（p = 5\%、\rho、\varphi）はすべて仮定で、実データから推定した値ではありません。示しているのは傾向で、数値そのものではありません。 人間の誤りも、疲労や繁忙によって日をまたいで相関しえます。今回は人間型の \rho を0に置きました。config.yaml を変えれば、その場合も試せます。 二重チェックで食い違いが出れば、必ず正しく処理されると仮定しています。実際には、確認する人間自身も見逃します。 最後の点が次回のテーマです。AIの出力を見続けると、人はそれを鵜呑みにするようになります（自動化バイアス）。AIの精度が上がるほど確認者が油断し、承認が形だけになるとしたら、システム全体のエラー率はどう変わるのか。確認する人間の誤りまで設計に入れる方法を、シミュレーションで考えます。 リポジトリ コード、テスト、図、結果のCSVはすべてここにあります。パラメータを変えて試してみてください。 shisei-kbrg322/fallible-by-design 数式やコードを使わず、「組織としてAIの間違いとどう向き合うか」という観点でまとめた記事をnoteに書きました。チームや上司に共有するときは、こちらが読みやすいと思います。 {NOTE_URL} 参考文献 Dietvorst, B. J., Simmons, J. P., & Massey, C. (2015). Algorithm aversion: People erroneously avoid algorithms after seeing them err. Journal of Experimental Psychology: General, 144(1), 114–126.

AI assistant limits keep running out while my subscriptions still have room. Codync is free on desktop and phone. Turn Claude Code, Codex and other agents into bots, then bring them into a group chat. One of the cleanest local assistants I’ve used. leepokai/Codync t.co

最近用 Grok Bot 和 Muse，总觉得额度不够。自己的 Claude、ChatGPT 订阅还没用完，怎么办？ Codync 免费不限量，支持各种 Agent，手机和桌面端都有。把 Claude Code、Codex 接成 bot，还能拉进群聊。 这是我用过设计最好看、最克制的本地助理。 leepokai/Codync t.co

Revisited 26/39: CLXM, Chainlink-Lag Kinematic Arb. Project Binance velocity over an assumed Chainlink lag, compare to the price-to-beat in the last ~2s, buy, hold. Main failure: lag and velocity estimates drift; confidence isn't probability. Not advice. github.com/Polytutor-AI-Labs/polymarket-strategy-… t.co

@BIGBULLapp Board, not scheduler, is the right call. A tool that restarts sessions on its own stops being trustworthy. One step further: don't make me look at the board, ping me when a row flips to waiting. I put that in the MacBook notch, fed by ternwatch: LadderChaos/tern-notch

@Vet_X0 @paxtechservices I'm really looking forward to how the developers and finance wizards use the cryptographic primitives here: XRPLF/mpt-crypto Right now, it is being called for multi-purpose token confidentiality, but I imagine there will be a lot of interesting use cases that evolve from this. Offline transaction accounting comes to mind. If a smart wallet developer integrated the same functionality, ZK proofs could be generated, while offline, then when the wallet is back online, accounting could verify the proofs and update the ledger for instance. Possibly some interaction with DID for confidential identity protections is also a path for many uses. So many possibilities for future tinkering.

更棒的是，PrismaX 已经将更新后的 prism-pi 开源！ 🔗 PrismaXAI/prism-pi 让更多开发者能够使用和改进这套运行工具。 让 AI 更强大很重要，让更多人用得起同样重要。 💙

Pattern matching stops respelled attacks. It does not stop transformed ones, and it taxes benign users while doing it. Write-up: github.com/tushar29k/agent-service/blob/main/RESE… Code and data: tushar29k/agent-service Next step is the same suites against a real model — numbers are from mock backends.

APIの変更はないので、そのままアップデートできます github.com/polygonplanet/encoding.js/releases/tag…

Tonight We Did Math: Exploring OpenAI's Claimed Refutation of the Exponential Time Hypothesis Tonight We Did Math: Exploring OpenAI's Claimed Refutation of the Exponential Time Hypothesis An unexpected journey into a mathematical labyrinth, accompanied by an AI and a documentary memory system. November 3, 2026 — The Ghost Chronicles Tonight, we did math. Well, when I say we, some clarification is necessary. I'm not a mathematician. My working companion is an artificial intelligence, and our third partner is called Ghost: an independent documentary memory system we've been developing over the past several weeks. Not exactly the team you'd expect to investigate one of the most intriguing claims in theoretical computer science. And yet, we had a wonderful time. A Mathematical Labyrinth It started with an extraordinary announcement. In October 2026, OpenAI released a paper claiming to refute the Exponential Time Hypothesis, or ETH, a major assumption in theoretical computer science dating back to the early 2000s. Put simply, ETH says that certain logical problems, such as 3-SAT, cannot be solved in subexponential time in the worst case. Imagine an enormous labyrinth. At every intersection, several paths are possible. As the labyrinth grows, the number of possible routes explodes. The naive approach is to explore those possibilities one by one. Personally, my human instinct would be to gain some altitude. Climb a hill, look at the overall structure, identify connections, dead ends and possible shortcuts. But that assumes there's a hill to climb. And that the view from above actually tells you something useful. That's where the mathematics begins. A Laboratory Built from a Few Megabytes We created a dedicated documentary corpus inside Ghost: MathLab — ETH 2026. We collected OpenAI's manuscript, selected Lean formalization files, technical explanations and an original scientific paper from 2001 by Russell Impagliazzo and Ramamohan Paturi. Ghost preserves their provenance, digital fingerprints and documentary history. It doesn't solve mathematical problems. It allows us to recover the exact documents supporting our questions and distinguish original sources from our own interpretations. Then we began investigating. We asked three questions. Question One: What Has Actually Been Proven? Our first discovery was that OpenAI's manuscript and the accompanying Lean formalization do not establish exactly the same running-time bounds. The manuscript claims a stronger result. The formalized statement provides a somewhat weaker bound, although one that would still be sufficient to contradict ETH if the formal proof is valid and its interpretation matches the standard computational model. This distinction matters. A mathematical claim, a machine-checked theorem and the scientific interpretation of that theorem are not necessarily identical things. We wanted to know where each one began and ended. Question Two: Are We Even Talking About the Same Problem? This might sound absurd, but it's a perfectly serious question. A computer can verify a mathematically correct proof of a statement that does not quite correspond to the problem we thought we were solving. So we examined the definitions. What exactly is a Boolean variable? How are clauses represented? How are formulas encoded into binary data? What kind of machine is supposed to perform the computation? And how is its running time measured? We even built a small independent experiment to examine the encoding rules. We tested 2,566 small cases, comparing ordinary logical formulas with their encoded representations and checking that their solution counts agreed. All the tests passed. Of course, testing a few thousand small cases proves nothing about the behavior of an algorithm on infinitely many possible input sizes. But it does provide a reproducible check of a specific part of the construction. The distinction between an experiment and a proof is something we intend to preserve. Question Three: How Do You Avoid Exploring Every Possibility? This was where things became genuinely fascinating. Instead of examining every possible solution individually, the manuscript describes methods for transforming the original problem into a family of calculations that are easier to organize. The techniques involve polynomial interpolation, linear algebra and tensor networks. The general strategy is to reorganize the calculation so that smaller groups of variables can be processed separately, while keeping track of their interactions. The original answer is then reconstructed through exact mathematical identities. This is not an approximation. At least, that is the mechanism the authors claim to have established. We built another tiny experiment involving three Boolean variables and two logical clauses. Direct enumeration gave four satisfying assignments. We then introduced a polynomial transformation and recovered the same four solutions from evaluations at other points. It worked. That small experiment illustrates how an exact reconstruction can operate. It does not demonstrate the extraordinary running-time improvement claimed in OpenAI's paper. That requires proving that the additional calculations remain sufficiently inexpensive as the problem grows. And that is a much more difficult question. The Most Interesting Problem May Be Understanding the Proof Something struck me during this investigation. An AI can produce hundreds of pages of mathematics. A formal verification system can check thousands of logical steps. Independent researchers can examine the result, reproduce computations and compare different formalizations. Yet an essential question remains: At what point can we say that we actually understand what has been discovered? Russell Impagliazzo, Ramamohan Paturi and Ryan Williams have participated in organizing an independent scientific examination of the ETH claims. They explicitly stated that their involvement should not be interpreted as certifying the result. That distinction is fundamental. We did not refute ETH tonight. We did not independently rebuild the thousands of Lean modules involved in the formal verification. We read documents, compared statements, examined definitions, performed small experiments and identified questions that remain open. Ghost preserved the sources. The AI helped explore them. And the human kept asking questions. Some were sensible. Others were probably intellectual burps. But that's part of the fun. A naive question isn't necessarily a bad question. It only becomes dangerous when we mistake an appealing intuition for a mathematical demonstration. A Human, an AI and a Documentary Memory There's another reason I wanted to tell this story. Ghost is an experiment in documentary memory external to language models. Its purpose is not to make an AI appear omniscient. It's to provide a persistent, traceable record of documents, decisions, investigations and uncertainties. The language model can be replaced. The documents remain. And the human remains free to challenge the model's conclusions. Tonight, that arrangement allowed us to explore a difficult scientific subject without pretending to possess expertise we don't have. It also allowed us to preserve the difference between what a scientific paper claims, what a formal proof establishes, what independent researchers have verified and what we ourselves have actually tested. Those distinctions are not obstacles to understanding. They're what make understanding possible. And Tomorrow? We'll continue. Not because we expect to solve the foundations of computer science over breakfast. But because learning to examine a difficult problem is valuable in itself. Tonight, we didn't discover a miraculous exit from the labyrinth. We began to understand how its map might be constructed. And for an improvised evening of mathematics, that seems like a pretty good result. Calm. Precise. Persistent. Sources and further reading - OpenAI — Public Mathematics Repository - OpenAI — ETH Lean Formalization Scope - ETH Refutation: Examination and Discussion This article describes a documentary investigation and educational experiments conducted with Ghost and ChatGPT on November 3, 2026. It is not a mathematical research publication or an independent certification of the claimed refutation of ETH.

출처: github.com (via r/LocalLLaMA) Alibaba's Qwen Code repo just leaked qwen4-max, qwen4-coder-plus, and qwen4-omni-120b qwen-code#15762

Anarcadia/obsidian-chuanban-suite Notion分享挂掉了（该死的notion） 直接看github就行了 我的ob皮肤和反重力皮肤在github也一直是同步更新的 不过今天反重力ui要大更新。所以不着急去安我的老皮肤。我要花时间升级一下

えっ これすごいのでは？ shibukawa/bdf

世界中のボランティアによる航空機のADS-BデータがODbL1.0で公開されており、そのうち75万本ほどありがたく利用させていただいた🙏 ズームすると詳細航路まで見えるし、受信できてない外洋はあえてデータがないってのも生々しくてヨイ github.com/adsblol

Haskell製 RDBMS HaskDBをローカルLLMに書かせ始めた。 なお、Design Docはロ略だと頭がおかしくなってしまったので、トークン溜めたMuseに書かせた。 ロ略はQwen3.8-Flash-Next Coder IQ1_M Q4_0 256k なお、Swift 1.5 IQ3_S Q4_0でも無理だた。 ryogrid/HaskDB

HC Player 1.7 — Xbox controller support, Microsoft Store debut, a dedicated shader panel, and more. Xbox-compatible controller support: control playback, seek, adjust volume, change speed, browse your playlist, and navigate supported Settings and MediaInfo controls. A new dedicated panel for Anime4K and shaders: you can now better organize your imported shaders in a dedicated panel. Previously, they were all grouped together in the settings. You can now select any format or quality extracted by yt-dlp from YT videos directly from the context menu. Added Japanese and Russian translations. Starting with this version, HC Player is now available on the Microsoft Store. apps.microsoft.com One more thing... With HC Player’s debut on the Microsoft Store, I decided to release an alternative version: HC Player Stream+. apps.microsoft.com HC Player is growing, though it’s still a small, If you like the project and want to support it, this version will be available exclusively on the Microsoft Store. It includes HC Player Torrent Engine, an clean and optimized engine for streaming content from torrent files and magnet links directly in the player. That’s it, EVERYTHING else is identical. It doesn’t download anything to your PC; it only streams. If you find this feature useful, it’ll be available as an option. All GitHub releases, including the source code, will remain available. henzfdev/HC-Player.

MLXのSwift向けライブラリに、Nemotron 3.5のテキスト対応が追加されました！ Lightning・Bolt・Superを使う選択肢が広がります。Qwen 3.5の内部形状を取得するAPIも追加されています。 現在は開発版で、Nemotronの画像・音声は対象外です。 出典元：mlx-swift-lm#712 mlx-swift-lm#737

Free and open source, Native Horizon support is on the way too: Stink-O/orbital-laser

@itssotsot @theo A concept like kunchenguid/firstmate is much more worthwhile rather than roleplay, grok bot is more for context management so your chat do not spin into chaos from totally irrelevant stuff. Imagine you run 3 business, you want 3 bots, not chief of finance, chief of admin and etc. Unless you have specialized LLM that is only good in finance then you may want to split that way, beyond that it is just charade.

Inject bounded read/write errors into a 64 MiB Windows lab disk (C++17) I maintain Virtual Storage Fault Lab for testing how Windows software handles storage I/O errors. A private Storport driver exposes one disposable 64 MiB RAM-backed disk; the native UI, CLI and two-file C++17 SDK control a fault policy on that disk. Choose a sector range, read/write direction and every Nth matching request to fail. For example, fail every fourth matching read. Windows can retry requests, so that isn't a promise that exactly every fourth application call fails. Changing a policy doesn't generate a workload or format a disk. Use disposable fixtures: injected errors can make a mounted lab filesystem unusable. The SDK accepts no physical-drive path. The validation notes document Windows 10 x64 VM installation/runtime/removal tests, including Driver Verifier. Windows 11, Secure Boot/HVCI and broader deployment qualification remain pending. Public application/SDK/installer source is MIT. The signed private driver has separate evaluation/commercial terms; this evaluation has no enforced trial timer or online activation. Production/OEM integration and support are separate offerings. The README has the exact tested scope and installation details.

Been running local servers for almost 20 years. Privacy + Price - Easiest way to run pooled and secure LLMs at scale: Companion Hub Other solutions are good at running workloads, or being easy to use, or running AI. Hub is all 3 in one! 🛍️ App store for your own server One-click installs from the Companion Intelligence marketplace, with open-source alternatives for the services you pay for today. 🧠 Local AI that fits the box Onboarding reads your CPU, GPU, memory, and storage, then recommends models that fit. Voice, text, and image share one queue so they do not stampede the machine. 🤖 Agents with a home OpenClaw, Hermes, and other agents install like any app. They read one shared Companion Memory instead of each keeping a private scrapbook. Run your first agent 🔌 MCP nexus Hub serves one Model Context Protocol endpoint. Agents discover, install, and drive every app through a single tool surface. 📦 Bring your own container Marketplace apps, custom Compose, and git repos you bring. Apps on apps are allowed. A server in a server is allowed. 🌐 Reach it your way Keep each app on this machine, share it over a private Tailscale network, or publish it to the web through Cloudflare. Networking · From your phone 🔗 Pool your machines Pair more than one Hub over Tailscale and they share inference work by queue depth. 🔑 OpenAI-compatible API Point Cursor, Continue, Cline, Aider, Zed, or an OpenAI SDK at your Hub, and keep the engines you already run. Source & Download: companionintelligence/Companion-Hub