🏡

to read (pdf)

generated: June 04, 2026 at 00:30:09

June 04, 2026
1. 🔗 Console.dev newsletter mq rss
  
  Description: Query, filter, transform Markdown.
  
  What we like: Extract content from Markdown, then apply transformations to the content. Works as both a CLI and a REPL environment. Options to convert other formats e.g. CSV into a Markdown table. Syntax is similar to jq. Has an MCP server for AI usage.
  
  What we dislike: Nothing!
2. 🔗 Console.dev newsletter Slumber rss
  
  Description: Terminal HTTP client.
  
  What we like: TUI and CLI for making REST and other HTTP client requests. Config-based recipes for building requests. Can import collections from other formats e.g. OpenAPI. Templates for dynamic requests. Also works as a Python package.
  
  What we dislike: Only supports HTTP.
June 03, 2026
1. 🔗 daaain/claude-code-log Release 1.4.0 release
  Changed
  - Fix sed
  - Add MkDocs documentation site with live TUI reference (#197)
  - Relax Textual constraint from== to >= (#196)
  - Add--version flag to the CLI (#195)
  - Fix AskUserQuestion result rendering + highlight chosen options (#180) (#189)
  - Derive render_session_id from the SessionTree, not a loop variable (#190)
  - Fix collapsible body overlapping preceding content in tool cards (#153) (#187)
  - Extract compute_session_data + compute_project_aggregates (C9b) (#188)
  - Add C9a characterization tests for session-scan call sites (#186)
  - Route converter summary + ai-title extraction through shared helpers (#185)
  - status: Wave B fully merged; Wave C kickoff (C8/C9a/C9b stacked, C10 dropped, decisions locked)
  - Compute branch preview once from the DAG-line (#184)
  - status:#184 fully validated (CI 11/11, CodeRabbit clean) — ready to merge
  - docs: keep simplification status note self-contained to project scope
  - status: correct#184 state; move GitHub CI/CodeRabbit ops to github guideline
  - status: reverse-order stacked-PR lift recipe CONFIRMED on#184
  - Factor session-header construction out of _render_messages (#183)
  - status:#183/#184 rebased + CodeRabbit forced (#183 clean, #184 2 doc fixes); record @coderabbitai + reverse-order workarounds
  - Dedup requestId tokens in pagination cache-miss fallback (#182)
  - status: Wave B track complete — opp 7 PR#184 up, all monk-approved; add merge sequence
  - status: note stacked-PR CI/CodeRabbit defers to merge-time
  - status: opp 1 green (#182, awaiting merge); opp 6 #183 in review; opp 7 in progress
  - status: opp 1 - > PR #182 (in review); opp 6 in progress
  - Add live-status section to simplification plan
  - Add converter/renderer simplification plan
  - Move detail-visibility predicate onto MessageContent (#181)
  - Sync rendering-architecture.md §5 with the current pipeline (#178)
  - Extract inline junction-forward-link block into a named pass (#177)
  - Co-locate the away-summary detail rule on AwaySummaryMessage (#176)
  - Remove vestigial progress-chain parent repair (#175)
  - plugins: dev-docs gaps + public helper API + ToolResult example (Phase 2) (#173)
  - Implement unified plugin system from RFC#166 (#169)
  - Render Read tool results with pygments via structured payload (closes#170) (#172)
  - work/: triage against shipped main (#171)
  - Always regenerate projects index so variant-flag toggles refresh links (#168)
  - RFC: plugin system (unified message-transformer mechanism) (#166)
  - Per-message timestamps in Markdown output (#160) (#165)
  - Support non-GitHub forges via static map +--git-link fallback (#156) (#164)
  - Obsidian-friendly output: --output dir + --expand-paths + --filter-path (#151) (#155)
  - Linkify commit SHAs in rendered Markdown + HTML — closes#156 (#161)
  - CSS clean-ups (issue#153) (#163)
  - Cross-link TaskOutput / TaskUpdate headers back to their spawn (#154) (#158)
  Full Changelog : 1.3.0...1.4.0
2. 🔗 backnotprop/plannotator v0.19.27 release
  Follow @plannotator on X for updates
  
  Missed recent releases? Release | Highlights
  ---|---
  v0.19.26 | Amp plugin production fixes, Mermaid rendering fix, Settings flicker fix, update notification toast and shimmer
  v0.19.24 | Amp integration, configurable data directory, Auto Mode permission option, Pi plan approval fix
  v0.19.23 | Droid integration, Windows Pi AI fix, quieter update indicator
  v0.19.22 | Safari copy fix in plan viewer, CLAUDE_CONFIG_DIR support for session logs
  v0.19.21 | Ask AI in plan review and annotate mode, shared AI runtime, origin-aware provider defaults
  v0.19.20 | Interactive goal setup UI, OpenCode submit_plan fixes, browser no-op sentinel handling for Claude agents
  v0.19.18 | Edit-based submit_plan for OpenCode, Pi namespace migration, Codex annotate-last fix, OpenCode commands dir fix
  v0.19.17 | Reworked goal setup skill (interview-driven flow), CLI --version flag
  v0.19.16 | Code navigation with peek view (Cmd/Ctrl+click tokens in diffs)
  v0.19.15 | Commit-based diff base, jj evolution diffs, GitLab reliability fixes, OpenCode command intercept fix
  v0.19.14 | Visual explainer skill update, PFM code-file hover previews, Graphviz, diff tab size and line bg intensity, hooks settings tab
  
  What's New in v0.19.27
  
  v0.19.27 adds Kiro CLI as a supported agent, introduces Glimpse native window support, and ships a message picker for annotate-last. Nine PRs total, six from external contributors, three first-timers.
  
  Kiro CLI Integration
  
  Plannotator now supports the Kiro CLI agent harness. The integration uses Kiro's native skill and custom agent model rather than a plugin or hook. The installer auto-detects Kiro when ~/.kiro exists or kiro-cli is on PATH, then installs five skills and a custom agent configuration file. Three skills are Kiro-specific with the kiro-cli origin baked in (review, annotate, archive), and two are shared with other agents (setup-goal, visual-explainer).
  
  The custom agent file at ~/.kiro/agents/plannotator.json wires all five skills together with a shell tool scoped to plannotator .*. The installer never overwrites an existing agent file, so users who customize it won't lose their changes on upgrade. All three platform installers (bash, PowerShell, CMD) received the same update.
  - #837 closing #794, contributed by @ashwinjohn3
  Annotate-Last Message Picker
  
  Running plannotator last after /rewind used to silently annotate the orphaned pre-rewind message. The annotation UI now surfaces recent assistant messages so you can pick which one to annotate.
  
  Two new affordances appear when there are multiple messages to choose from. A "Message N of M" button in the sticky toolbar lets you switch between messages while staying in the same session. A Messages tab in the sidebar shows the full list with annotation counts per message. Your annotations are preserved when you switch. On submit, only messages you actually annotated are included in the feedback.
  
  When there is only one message, the behavior is unchanged from previous versions.
  - #809 closing #800, contributed by @GLips
  Glimpse Native Window
  
  Plannotator can now open in a Glimpse native window instead of a browser tab. Glimpse provides a lightweight, borderless WebView window that feels more integrated than a random browser tab opening in the background.
  
  The feature is auto-detected: if glimpseui is on PATH and no explicit browser is configured via PLANNOTATOR_BROWSER, the server spawns Glimpse automatically. If Glimpse isn't installed, everything works exactly as before. Remote sessions never attempt Glimpse. The window size defaults to 1280x900 and can be adjusted via PLANNOTATOR_GLIMPSE_WIDTH and PLANNOTATOR_GLIMPSE_HEIGHT. To disable Glimpse entirely even when installed, set PLANNOTATOR_GLIMPSE=0 or add { "glimpse": false } to ~/.plannotator/config.json.
  - #840, contributed by @bjesuiter
  Pi Approval Continuation Fix
  
  The previous fix for Pi plan approval (#805 in v0.19.24) sent the continuation message as a deliverAs: "followUp", which caused a visible "Follow-up: Continue with the approved plan." row to appear in Pi's TUI. This release replaces that with an idle-wait approach: after approval, the extension polls until Pi reports idle, then sends a normal user message. The visible queue artifact is gone.
  - #843, contributed by @xz-dev
  Additional Changes
  - List marker alignment in diff view : List bullets and numbers in the plan-diff clean view now align to the first line of multi-line items instead of centering vertically against the full wrapped height. — #838, contributed by @rcdailey
  - Goal setup "grill first" interview : The setup-goal skill now supports an opt-in deep-dive interview step in Phase 1 that walks the decision tree one question at a time before building the bundle. — #839, contributed by @dgrissen2
  - Glimpse disable config : A PLANNOTATOR_GLIMPSE environment variable and glimpse config option let users disable Glimpse even when it's installed.
  - Multi-message annotation performance : The multi-message annotation export now computes lazily at submit time instead of re-parsing all messages on every annotation change.
  - Kiro on homepage : Kiro CLI is now listed in the agent selector on plannotator.ai.
  Install / Update
  
  macOS / Linux:
```
curl -fsSL https://plannotator.ai/install.sh | bash
```
  Windows:
```
irm https://plannotator.ai/install.ps1 | iex
```
  Claude Code Plugin: Run /plugin in Claude Code, find plannotator , and click "Update now".
  
  OpenCode: Clear cache and restart:
```
rm -rf ~/.bun/install/cache/@plannotator
```
  Then in opencode.json:
```
{
  "plugin": ["@plannotator/opencode@latest"]
}
```
  Pi: Install or update the extension:
```
pi install npm:@plannotator/pi-extension
```
  Droid: Install via the plugin marketplace:
```
droid plugin marketplace add backnotprop/plannotator
droid plugin install plannotator@plannotator
```
  Amp: Install the CLI first, then copy the plugin:
```
mkdir -p ~/.config/amp/plugins
curl -fsSL https://raw.githubusercontent.com/backnotprop/plannotator/main/apps/amp-plugin/plannotator.ts \
  -o ~/.config/amp/plugins/plannotator.ts
```
  Kiro CLI: The installer auto-detects Kiro and installs skills automatically. After installing the CLI, launch with:
```
kiro-cli chat --agent plannotator
```
  What's Changed
  - feat: Kiro CLI integration (skills + custom agent, cross-platform installers) by @ashwinjohn3 in #837
  - fix(ui): align list markers to first line in clean diff view by @rcdailey in #838
  - feat(setup-goal): opt-in "grill first" interview step in Phase 1 by @dgrissen2 in #839
  - feat: open Plannotator in Glimpse when available by @bjesuiter in #840
  - fix(pi-extension): avoid visible approval follow-up queue by @xz-dev in #843
  - feat: annotate-last message picker (fixes #800) by @GLips in #809
  - perf: defer multi-message annotation export to submit time by @backnotprop
  - feat(marketing): add Kiro CLI to homepage agent selector by @backnotprop
  - feat: add PLANNOTATOR_GLIMPSE env var to disable Glimpse native window by @backnotprop
  New Contributors
  - @ashwinjohn3 made their first contribution in #837
  - @GLips made their first contribution in #809
  - @bjesuiter made their first contribution in #840
  Contributors
  
  @ashwinjohn3 built the Kiro CLI integration from scratch, wiring up skills, a custom agent, and cross-platform installer support that mirrors the existing Codex and Gemini auto-detect pattern. @GLips both reported and fixed the annotate-last message selection issue, contributing the full message picker UI including the sidebar Messages tab, per-message annotation state, and multi-message feedback export. @bjesuiter contributed Glimpse native window support, adding auto-detection and fallback logic to both the Bun and Pi server browser-opening paths. @xz-dev returned with a follow-up to the Pi approval fix, replacing the visible follow-up queue with an idle-wait polling approach. @rcdailey fixed list marker alignment in the plan-diff clean view by extracting the ListItemBody component and adding items-start to the flex container. @dgrissen2 added the opt-in "grill first" interview step to the setup-goal skill, extending Phase 1 with a deep-dive question flow for vague or interdependent goals.
  
  Full Changelog : v0.19.26...v0.19.27
3. 🔗 anthropics/claude-code v2.1.162 release
  What's changed
  - claude agents --json now includes waitingFor showing what a waiting session is blocked on (e.g. permission prompt)
  - --tools: explicitly listing Grep/Glob now provides the dedicated search tools on native builds with embedded search (previously these names were silently ignored)
  - /effort now confirms when your chosen level will persist as the default for new sessions
  - Clicking a slash command in the autocomplete menu now fills it into your prompt instead of running it immediately; press Enter to run
  - Remote Control now shows as a persistent footer pill (with a link to the session) instead of a startup message
  - Renamed Windsurf to Devin Desktop in the /ide menu, /terminal-setup, and /scroll-speed, following the editor's rebrand
  - Fixed a silent startup hang when the config directory is read-only or unwritable — Claude Code now starts with in-memory config and surfaces startup errors instead of showing a blank screen
  - Fixed WebFetch permission rules not being applied to built-in preapproved domains; explicit WebFetch(domain:...) deny/ask/allow rules now take precedence over the preapproved-host auto-allow
  - Fixed Windows permission rules never matching when spelled with backslashes (~\, \\server\share) or case-variant paths, and Read deny rules not hiding files from Glob/Grep results
  - Fixed an interrupt (Esc) sent at the very start of a turn being silently dropped in stream-json/SDK sessions, leaving the turn running with no "Interrupted" feedback
  - Fixed API 400 no low surrogate in string errors for classifier side-queries and MCP server descriptions containing emoji near a truncation boundary
  - Fixed MCP per-server timeout config values below 1000 ms being floored to a 1-second watchdog that aborted every tool call; sub-1000 ms values are now ignored (falling back to MCP_TOOL_TIMEOUT or default), and claude mcp get annotates them accordingly
  - Fixed the LSP tool's workspaceSymbol operation returning no results; it now accepts a query parameter and passes it to the language server
  - Fixed claude agents cutting live status text (tool args, replies, prompts, exec output) at 60–120 columns on wide terminals; the status detail now uses the full terminal width
  - Fixed claude agents truncating long session names at 40 columns; the name column now grows with terminal width
  - Fixed claude agents attach occasionally bouncing straight back to the session list on the first try after a background-service restart
  - Fixed claude agents Ctrl+V image paste doing nothing in the dispatch input and the session reply box; pasting with no image now shows a hint
  - Fixed backgrounding a session with ← silently losing the conversation when the background service cannot start; the session stays in the list as a failed row you can wake with Enter
  - Fixed replies from the agents view that fail to send being lost; they are now queued for delivery on the next session start
  - Fixed cross-session messaging (SendMessage) silently breaking when CLAUDE_CODE_TMPDIR or $TMPDIR points at a deep directory
  - Fixed opening a running background session from claude agents stalling for 5 seconds before attaching
  - Quieter startup: notices group by severity, and session info and announcements share a single line per launch
  - Startup warnings rewritten to be shorter and clearer, each with a concrete fix
  - Launch-prompt warnings (deep link/pre-filled prompt) now stay pinned below the input until you act instead of scrolling away
  - Failed turns now show a compact warning line instead of a multi-line red error block
  - Improved background service startup and claude update verification to wait out endpoint-security scanning of new binaries instead of failing after 5 seconds
  - Background dispatch spawn failures now report the error class name when no errno is available
  - Removed the "Claude in Chrome enabled" and "marketplace installed" startup messages; model auto-updates and the team-onboarding tip now show as quiet notices under the logo
4. 🔗 r/Harrogate Moving to Harrogate rss
  
  Hey!
  
  I’m currently looking at moving to Harrogate from Newcastle. I have a few friends in Harrogate and every time I visit, the place just feels extremely peaceful (which is the opposite of where I currently live - it honestly feels like two different worlds).
  
  I’ve done some research and Harrogate seems very safe overall, but I was wondering if there are any areas that locals would recommend avoiding, or areas you’d particularly recommend?
  
  A bit about me: I work in tech, teach yoga on the side, enjoy fitness, nature, cafes, walking, and generally prefer a quieter lifestyle over nightlife. One of the things that’s drawing me to Harrogate is the balance between a smaller town feel and still being well connected to Leeds and York.
  
  I’m also curious about the wellness/fitness scene. Are there any yoga studios, gyms, run clubs, wellness communities, or other groups you’d recommend? I’d be looking to get involved and build a bit of a community if I move.
  
  I’d also love to hear from anyone who moved to Harrogate from a larger city. How did you find it? Any unexpected pros or cons?
  
  Thank you!
  
  submitted by /u/Technical_Bet_1575
  [link] [comments]
5. 🔗 r/reverseengineering Automated Fault Injection Attack Framework rss
  
  submitted by /u/SkrilHexNukehul
  [link] [comments]
6. 🔗 r/LocalLLaMA More Gemma 4 models incoming rss
  
  | https://x.com/i/status/2062237998415069224 possibly the 120B model submitted by /u/Deep-Vermicelli-4591
  [link] [comments]
  ---|---
7. 🔗 r/reverseengineering x86 assembly: Why you only need Paris to beat Pizza Tycoon (1994) rss
  
  submitted by /u/Optdev
  [link] [comments]
8. 🔗 Jeremy Fielding (YouTube) How To Get Almost Any Part for Free Or Very Cheap 8 Resources You Probably Don't Know exist rss
  
  If you want to join my community of makers and Tinkers consider getting a YouTube membership 👉 https://www.youtube.com/@JeremyFieldingSr/join
  
  If you want to chip in a few bucks to support these projects and teaching videos, please visit my Patreon page or Buy Me a Coffee. 👉 https://www.patreon.com/jeremyfieldingsr 👉 https://www.buymeacoffee.com/jeremyfielding
  
  Social media, websites, and other channel
  
  Instagram https://www.instagram.com/jeremy_fielding/?hl=en Twitter 👉https://twitter.com/jeremy_fielding TikTok 👉https://www.tiktok.com/@jeremy_fielding0 LinkedIn 👉https://www.linkedin.com/in/jeremy-fielding-749b55250/ My websites 👉 https://www.jeremyfielding.com 👉https://www.fatherhoodengineered.com My other channel Fatherhood engineered channel 👉 https://www.youtube.com/channel/UC_jX1r7deAcCJ_fTtM9x8ZA
  
  Notes:
  
  Technical corrections
  
  Nothing yet
9. 🔗 r/LocalLLaMA Introducing Gemma 4 12B: a unified, encoder-free multimodal model rss
  
  | submitted by /u/johnnyApplePRNG
  [link] [comments]
  ---|---
10. 🔗 r/reverseengineering Wow64 implementation details: How is Wow64 implemented in Windows 11 25H2 rss
  
  submitted by /u/_WinAsm
  [link] [comments]
11. 🔗 r/LocalLLaMA google/gemma-4-12B · Hugging Face rss
  | Gemma is a family of open models built by Google DeepMind. Gemma 4 models are multimodal, handling text and image input (with audio supported on E2B, E4B, and 12B) and generating text output. This release includes open-weights models in both pre-trained and instruction-tuned variants. Gemma 4 features a context window of up to 256K tokens and maintains multilingual support in over 140 languages. Featuring both Dense and Mixture-of-Experts (MoE) architectures, Gemma 4 is well-suited for tasks like text generation, coding, and reasoning. The models are available in five distinct sizes: E2B , E4B , 12B , 26B A4B , and 31B. Their diverse sizes make them deployable in environments ranging from high-end phones to laptops and servers, democratizing access to state-of-the-art AI. Gemma 4 introduces key capability and architectural advancements :
  - Reasoning – All models in the family are designed as highly capable reasoners, with configurable thinking modes.
  - Extended Multimodalities – Processes Text, Image with variable aspect ratio and resolution support (all models), Video, and Audio (featured natively on the E2B, E4B, and 12B models).
  - Diverse & Efficient Architectures – Offers Dense and Mixture-of-Experts (MoE) variants of different sizes for scalable deployment.
  - Optimized for On-Device – Smaller models are specifically designed for efficient local execution on laptops and mobile devices.
  - Increased Context Window – The small models feature a 128K context window, while the medium models support 256K.
  - Enhanced Coding & Agentic Capabilities – Achieves notable improvements in coding benchmarks alongside native function-calling support, powering highly capable autonomous agents.
  - Native System Prompt Support – Gemma 4 introduces native support for the system role, enabling more structured and controllable conversations.
  https://developers.googleblog.com/gemma-4-12b-the-developer-guide/ feed your potato!!! https://huggingface.co/ggml-org/gemma-4-12b-it-GGUF https://huggingface.co/unsloth/gemma-4-12b-it-GGUF submitted by /u/jacek2023
  [link] [comments]
  ---|---
12. 🔗 Confessions of a Code Addict Why Git Has a Variable Named false_but_the_compiler_does_not_know_it rss
  Today, in weird C code tricks, I want to show you a small example from Git's source code.
  
  Recently, I was poking around the Git source when a directory name caught my eye, it was named "compiler- tricks". I thought, "This is a promising name, let's see what's inside of it".
  
  Inside this directory, there was a file called not- constant.c, and the whole file contained just this:
```
#include  <git-compat-util.h>
int false_but_the_compiler_does_not_know_it_ = 0;
```
  The variable name made me curious. Why would Git need a global variable whose name says that the value is false, but the compiler does not know it?
  
  To understand this, let's first look at where this variable is used.
  
  It is used inside a macro called NOT_CONSTANT in git-compat- util.h:
```
/*
* Prevent an overly clever compiler from optimizing an expression
* out, triggering a false positive when building with the
* -Wunreachable-code option. false_but_the_compiler_does_not_know_it_
* is defined in a compilation unit separate from where the macro is
* used, initialized to 0, and never modified.
*/

#define NOT_CONSTANT(expr) ((expr) || false_but_the_compiler_does_not_know_it_)

extern  int false_but_the_compiler_does_not_know_it_;
```
  The macro takes an expression and performs a logical OR with this global variable:
```
(expr) || false_but_the_compiler_does_not_know_it_
```
  Now, the global variable is initialized to 0, and Git never modifies it (I checked the entire Git codebase). So, logically, this expression is equivalent to:
```
(expr) || 0
```
  which is simply:
```
expr
```
  So, why write the code this way?
  
  The variable false_but_the_compiler_does_not_know_it_ is not declared as const. It also has external linkage and is defined in a different translation unit from the code that uses it. As a result, while compiling a file that uses NOT_CONSTANT, the compiler cannot prove that the value of this variable will always remain 0.
  
  In practice, it is always 0. But from the compiler's point of view, someone else could modify it.
  
  This is the whole trick. Git creates a value that is false at runtime, but not obviously false to the compiler. At this point, you might be wondering: what is the point of this trickery? To answer that, we need to look at where this macro is actually used.
  
  Paid subscribers help me justify spending time on these strange little code rabbit holes. If you enjoy this kind of systems writing, consider upgrading.
  
  Tripo AI Raises Nearly $200M to Advance AI 3D and World Models
  
  (Sponsored)
  
  Tripo AI builds AI 3D foundation models for high-demand 3D workflows across interior design, e-commerce, gaming, film, VR/AR, digital twins, robotics, and interactive entertainment.
  
  Used by more than 20 million users worldwide, Tripo AI helps creators, developers, and studios turn ideas into high-quality 3D assets faster, from product visualization and home design to game-ready assets and simulation workflows.
  
  Following nearly $200 million in Series A+ and A++ financing, Tripo AI is accelerating its research roadmap, product development, and global creator ecosystem. Its new research initiative, Project Eden, explores how AI 3D can move beyond single-asset generation toward persistent, editable, reusable, multi-agent interactive worlds.
  
  With Tripo AI, you can explore:
  - AI-generated 3D assets and production-ready meshes
  - Native 8K AI textures
  - Intelligent part segmentation for editable 3D workflows
  - Project Eden, Tripo AI's world model research initiative
  Start creating with Tripo AI ->
  
  Where Git Uses This Trick
  
  So, the question is, where does Git use this macro? One of the interesting uses appears in refs/files- backend.c. Git has code that tries to create a symbolic ref using a symlink. If that succeeds, it continues to the next update. If it fails, it falls back to creating a regular symbolic ref.
  
  The code looks like this:
```
/*
* By using the `NOT_CONSTANT()` trick, we can avoid
* errors by `clang`'s `-Wunreachable` logic that would
* report that the `continue` statement is not reachable
* when `NO_SYMLINK_HEAD` is `#define`d.
*/

if (NOT_CONSTANT(!create_ref_symlink(lock, update->new_target)))
    continue;
```
  To understand why this is needed, we need to look at how create_ref_symlink is defined.
  
  Depending on the build configuration, it can either be a real function:
```
static  int  create_ref_symlink(struct ref_lock *lock, const  char *target)
{
/* ... */
}
```
  Or, it can be compiled away into a constant expression:
```
#if defined(NO_SYMLINK_HEAD) || defined(WITH_BREAKING_CHANGES)
#define create_ref_symlink(a, b) (-1)
#endif
```
  So, when NO_SYMLINK_HEAD is defined, this expression:
```
!create_ref_symlink(lock, update->new_target)
```
  effectively becomes:
```
!(-1)
```
  In C, -1 is treated as true. Therefore, !(-1) is false. So, the compiler sees something like this:
```
if (0)
    continue;
```
  This causes the Compiler (clang in this case) to raise a warning that the continue statement is unreachable.
  
  But the problem is that this is only true for one build configuration. On other platforms, where NO_SYMLINK_HEAD is not defined, create_ref_symlink is a real function and the continue statement is reachable.
  
  Git wants to keep the same source-level control flow across these configurations. So it wraps the condition in NOT_CONSTANT, so that the compiler sees something like this:
```
if (!(-1) || false_but_the_compiler_does_not_know_it_)
    continue;
```
  At runtime, this still evaluates to false because false_but_the_compiler_does_not_know_it_ is 0.
  
  But at compile time, the compiler cannot prove that the condition is always false. As a result, it doesn't emit the unreachable-code warning.
  
  Why Git Added This Macro
  
  While that explained what this code does and where it is used, I was also interested in looking at the commit history behind it to udnerstand the original motivation.
  
  The NOT_CONSTANT macro was added in commit 82e79c63642c by Junio C Hamano (the maintainer of Git) in March 2025. The motivation was Git's experiment with Clang's -Wunreachable-code warning.
  
  This warning can be useful because it can catch genuinely unreachable code. But it can also produce false positives when the same source code is compiled across different platforms and build configurations.
  
  The original case was not the symbolic ref code. It was in run- command.c, around sigfillset().
  
  POSIX says that sigfillset() can fail, so Git wants to check its return value. But on some platforms, the system headers make it obvious to the compiler that sigfillset() always succeeds. In such builds, Clang sees the error handling branch and concludes that it is unreachable.
  
  One option would be to disable -Wunreachable-code, but that would also disable the useful warnings. Git's approach was to keep the warning enabled and add a small escape hatch for cases where the warning is known to be a false positive.
  
  The later refs change used the same escape hatch. In commit 3860985105a, Johannes Schindelin added NOT_CONSTANT around the create_ref_symlink condition because Clang was complaining in NO_SYMLINK_HEAD builds.
  
  So, this macro is a warning-management trick. It tells the compiler: this expression may look constant in this build, but please do not treat it as a compile-time constant.
  
  Could This Be Done Differently?
  
  But this problem is not unique to Git, many projects face similar problems and solve them in different ways. The following are a few alternate solutions.
  
  The most direct option is to directly wrap the call to create_ref_symlink using conditional preprocessor directives so that it compiles only on platforms where NO_SYMLINK_HEAD is not defined.
```
#ifndef NO_SYMLINK_HEAD
if (!create_ref_symlink(lock, update->new_target))
    continue;
#endif
```
  This would remove the unreachable code in NO_SYMLINK_HEAD builds. But it also spreads build-configuration logic into the middle of the control flow.
  
  Another option is to disable the warning locally:
```
#pragma  clang  diagnostic  push
#pragma  clang  diagnostic  ignored  "-Wunreachable-code"
if (!create_ref_symlink(lock, update->new_target))
    continue;
#pragma  clang  diagnostic  pop
```
  But this is compiler-specific and noisy. It also does not explain the real issue to anyone reading the code.
  
  You could also use volatile:
```
static  volatile  int not_constant_zero;
if ((expr) || not_constant_zero)
...
```
  This would also prevent the compiler from treating the value as a normal constant. But volatile has a stronger meaning. It tells the compiler that every read of the variable must really happen because the value may change outside the compiler's normal model. That is useful for things like memory- mapped I/O, but it is too strong for this case.
  
  The approach used by Git is much more precise. It uses an ordinary external variable defined in a separate translation unit. This is enough to hide the value from the compiler during normal compilation, without introducing volatile semantics.
  
  You could also use a function:
```
int  false_but_the_compiler_does_not_know_it(void);

if ((expr) || false_but_the_compiler_does_not_know_it())
...
```
  But then you may introduce an extra function call in the generated code unless the compiler or linker can optimize it away.
  
  So, the global variable trick is not the only way to do this. But it gives Git a small, reusable annotation for a very specific situation that they can apply anywhere this problem surfaces.
  
  If you are enjoying this article, you may also like my virtual memory article/ebook. It explains virtual memory from first principles and builds up to the details programmers usually hear about but rarely understand deeply: page tables, page faults, TLB shootdowns, NUMA placement, and more.
  
  Check out Virtual Memory Article
  
  Does the Linker Remove This Branch?
  
  This brings us to another interesting question.
  
  While this trick fools the compiler into believing that the branch may evaluate to true at runtime, in reality, we know that on NO_SYMLINK_HEAD builds, the branch is always false. So, the question is will link-time optimization (LTO) eliminate the branch from the final binary?
  
  To check this, I wrote a small reproducer with three files, similar to how Git structures this code.
  
  First, let's see the file that uses the variable:
```
extern  int false_but_the_compiler_does_not_know_it_;
extern  int  slow_path(void);

int  branch_test(void)
{
    if (0 || false_but_the_compiler_does_not_know_it_)
        return  slow_path();
    return  0;
}
```
  Then, the file that defines the variable:
```
int false_but_the_compiler_does_not_know_it_ = 0;
```
  And finally, a small main:
```
int  branch_test(void);

int  slow_path(void)
{
    return  42;
}

int  main(void)
{
    return  branch_test();
}
```
  To make this visible, I used a small reproducer where the branch calls slow_path(). This makes the branch easy to spot in the generated assembly if it survives optimization. I compiled it with Clang 18 using normal optimization and warning flags enabled:
```
clang-18  -O2  -Wall  -Wextra  -Wunreachable-code  -c  branch.c  -o  branch.o

clang-18  -O2  -Wall  -Wextra  -Wunreachable-code  -c  main.c  -o  main.o

clang-18  -O2  -Wall  -Wextra  -Wunreachable-code  -c  not_constant.c  -o  not_constant.o

clang-18  -O2  -Wall  -Wextra  -Wunreachable-code  \

branch.o main.o not_constant.o -o normal
```
  Then I used objdump to inspect the final executable. objdump -d disassembles the binary, which lets us see the actual machine instructions that survived compilation and linking:
```
objdump -d normal
```
  The final binary still contains the load and the branch. The following is a cleaned-up version of the output produced by objdump to focus on the interesting bits.
```
lea false_but_the_compiler_does_not_know_it_(%rip), %rax
cmpl $0x0, (%rax)
jne slow_path
xor %eax, %eax
ret
```
  Let's break this down instruction by instruction:
```
lea false_but_the_compiler_does_not_know_it_(%rip), %rax
```
  This computes the address of the global variable and stores it in the rax register.
```
cmpl $0x0, (%rax)
```
  This compares the value stored at that address with zero.
```
jne slow_path
```
  If the value is not zero, execution jumps to slow_path.
```
xor %eax, %eax
ret
```
  Otherwise, the function returns 0.
  
  So, we can see that with normal compilation and linking, the branch is still present in the final binary. The ordinary linker does not reason about the value of this global variable and doesn't remove the branch.
  
  PS: If you are interested in learning x86 assembly, I have a series in progress that teaches it. Check it out at the link below:
  
  Check out the x86 assembly series
  
  But then I tried the same experiment with link-time optimization:
```
clang-18  -O2  -Wall  -Wextra  -Wunreachable-code  -flto  \
branch.c main.c not_constant.c -o lto

objdump  -d  lto
```
  With LTO enabled, the branch disappears. The final main simply becomes:
```
&lt;main&gt;:
  xor %eax, %eax
  ret
```
  So what changed?
  
  Normally, the compiler optimizes each translation unit separately. When it compiles branch.c, it only sees this declaration:
```
extern  int false_but_the_compiler_does_not_know_it_;
```
  It does not see the definition in not_constant.c, so it cannot know that the value is always 0.
  
  With link-time optimization, the compiler keeps an intermediate representation of the code and performs optimization after seeing all the translation units together. At that point, it can see both the use of the variable and its definition. It can also see that nothing modifies it. As a result, it can prove that the condition is always false and safely remove the branch.
  
  That gives Git the best of both worlds. The trick prevents Clang from producing an unreachable-code warning during normal compilation. Later, if LTO is enabled, the compiler can still remove the useless branch from the final binary. In effect, this is similar to the conditional-compilation solution we discussed earlier, but without muddying the code with #ifndef directives all over the place.
  
  If you enjoyed this, you 'll probably enjoy the rest of the newsletter. I write about Python internals, compilers, assembly, operating systems, and performance engineering, helping you build the kind of low-level intuition that makes you a better programmer. Paid subscriptions help keep this work going.
  
  Share
13. 🔗 r/reverseengineering Hacking your PC using your speaker without ever touching it rss
  
  submitted by /u/nns_ee
  [link] [comments]
14. 🔗 r/LocalLLaMA Calling it now Microsoft is buying Unsloth. rss
  
  I am going to be honest, I am leery of this new partnership with Unsloth. Microsoft historically hated open source, and this will not benefit the community in the end. It will look great at first. They will drop updates, play nice, and everyone will celebrate.
  
  But if you have been around the block, you know exactly how this play ends. Microsoft spent decades aggressively trying to kill open source. A shiny PR campaign does not change corporate DNA.
  
  Calling it now, Microsoft is going to buy Unsloth and go after llama.cpp next. They just want to control how we run models locally so they can force everyone back onto their paid cloud servers. They do not buy things to keep them free. They buy them to trap you in their ecosystem, so do not act surprised when they pull the rug.
  
  Edit: I figured this would get some strong reactions, and I appreciate someone from Unsloth jumping in to say it is just a partnership. I am not trying to spread rumors, I am just calling it how I see it. Honestly, I hope I am wrong. I know Unsloth is a massive contributor to Hugging Face and a vital lifeline to open source, just like everyone else here who contributes.
  
  Also, I know people are looking at my account name and recent posts thinking I am a bot. In my first post ever, I said this account was a throwaway. I am real, and I actually write my own stuff. I am not here to karma farm, I just genuinely care about the future of open source and speak my mind.
  
  P.S. I miss the old days of Reddit, and I am trying to bring it back in my own way with open dialogue.
  
  submitted by /u/Wrong_Mushroom_7350
  [link] [comments]
15. 🔗 HexRaysSA/plugin-repository commits sync repo: +2 releases rss
```
sync repo: +2 releases

## New releases
- [augur](https://github.com/0xdea/augur): 0.9.2
- [haruspex](https://github.com/0xdea/haruspex): 0.9.3
```
June 02, 2026
1. 🔗 IDA Plugin Updates IDA Plugin Updates on 2026-06-02 rss
  IDA Plugin Updates on 2026-06-02
  
  New Releases:
  - ida-lifter v2.6.2
  - PseudoForge Release v0.1.1
  Activity:
  - atelier
    
    7f79cb97: Merge pull request #36 from atelier-runtime/cc
    
    d61c654c: refactor: update agent documentation and improve coding guidelines
  - augur
    
    88610ef5: doc: update documentation
  - capa
    
    09f5bd5a: Version number for deprecation
  - claude-marketplace
    
    14e62af9: Merge pull request #5 from msobon-hexrays/fix_term
    
    6edcb571: Rename term to del #4
  - GTA2_RE
    
    8ae65fce: upd
  - ida-domain
    
    9142ada4: Fix microcode dump test for new version of IDA (#82)
  - ida-lifter
    
    b62811db: fix: Resolve INTERR 50920 for narrow memory loads and enforce coverage
  - ida-pro-mcp
    
    6b5fe60f: fix(installer): skip IDA lookup for client-only installs
    
    d794f768: docs(search): regenerate combinator tool docs
    
    8b585d5e: fix(search): allow hunt recipe listing in live MCP
    
    f8772866: feat(installer): support coexisting IDA 9.2 and 9.3
    
    6c954d82: fix(search): make all 8 combinator actions work end-to-end against re…
    
    d8158f85: feat(search): add 8 combinator actions (bool, hunt, neighborhood, out…
    
    43880ccb: fix(ci): address CI-only test failures
    
    7b37a597: docs: regenerate tool skills to match current schemas
    
    8b471b74: fix(installer): preserve user config on JSONC/JSON5/malformed input
    
    b83b741d: fix(tests): resolve all remaining 44 pre-existing test failures
    
    6ed292f1: fix(tests): ack policy and init bookmark_mgr in test_bugfixes
    
    639c5881: dedupe(phase5): audited, no actionable dead-code targets
    
    11d40768: dedupe(phase4): audited, no actionable targets
    
    5a3b28f1: dedupe(phase3): cross-reference notes for intentional action overlap
    
    7a2e4d25: dedupe(phase2b): finish remaining cross-file helper consolidation
    
    6ce721de: dedupe(phase2): cross-file helper consolidation
  - idac
    
    f4f7f194: Merge pull request #14 from trailofbits/docs-cleanup
    
    7886f45c: docs and example fixups
  - NyLib2
    
    f5bc8c2d: Add Win32 font matching and auto-install
  - PseudoForge
    
    4648717a: Prepare v0.1.1 release documentation
    
    33fc58fa: Report LLM cyber policy fallback clearly
  - quokka
    
    47d3384e: Merge pull request #116 from quarkslab/dependabot/github_actions/acti…
  - rhabdomancer
    
    195a0880: feat: add syscall and ioctl to the list of insecure functions
  - Vegvisir-harness
    
    c49f0fe5: Enhance Agent Red template
    
    551f6818: Document manual-only vendored component updates
    
    9d8c3777: Install Solarium wrapper
    
    ccf7141d: Install binary intelligence workbench wrapper
    
    d17b3fec: Import binary intelligence workbench component
    
    d1926d38: Make subagent active limit configurable
    
    af1037e9: Update runtime feature documentation
    
    d5d2a418: Restore unlimited tool round default
    
    b8faa181: Preserve tool policy across rebuilds
    
    d807293b: Harden command and file sandboxing
2. 🔗 Evan Schwartz Scour - May Update rss
  Hi friends,
  
  In May, Scour scoured 865,266 posts from 28,671 feeds (1,766 of which were newly added), and 260 new users signed up to bring it across the 3,000 user mark!
  
  Here's what's new in the product:
  
  🔎 Smarter Interest Matching
  
  Scour is now better at finding posts that match your interests. You should see more relevant content and far fewer off-topic articles in your feed. (This sounds simple, but it represents at least a full month's effort 😅.)
  
  The way this works under the hood was one of the single biggest changes I've made to Scour's core ranking system since I started working on it. At a high level, scoring now combines Scour's original fuzzy concept matching (embedding vector distance) with how much the article uses relevant vocabulary (lexical search). While these ingredients are well-established, I think the exact way Scour implements them might be a somewhat novel system design.
  
  The reason this was so complex to build was that existing approaches to lexical search did not work for Scour. For example, every Scour user has between a handful and hundreds of interests (I have 642), each of which might have 3-10+ relevant keywords. This means that every "search" is actually a search for thousands of terms (for my feed, it's around 5,000). Most search systems are built for individual queries with a handful of terms. The even more tricky issue is that lexical search algorithms like BM25 do not produce scores that are comparable across queries, because they are designed for ranking (ordering results for a specific query), not scoring. Scour, however, needs to know which of your interests a given post is most related to and it sorts the posts in your feed by how relevant they are for any of your interests. I believe that the custom scoring and indexing system Scour now uses provides both cross-query score comparability and efficient lookup for thousands of parallel queries. Stay tuned for more details!
  
  🙏 Help me out! Please like, dislike, and report posts as off-topic as you're browsing. These signals help me tune the system and figure out the edge cases where it could be improved.
  
  🔠 Better Title Keyword Bolding
  
  Scour bolds keywords in the post titles to make the feed easier to skim. The new lexical scoring layer discussed above makes it easier to bold exactly the words related to your interest.
  
  📃 Peeking Under the Hood
  
  Two other small changes let you peek under the hood of the new scoring system. On desktop, hovering over a post's title will show you the score breakdown between semantic and lexical. Separately, if you click on an interest tag and go to the single-interest page, there is now an Advanced link that will show you the terms the lexical scoring system is using to find and rank posts.
  
  🔖 Some of My Favorite Posts
  
  Here were some of my favorite posts that I found on Scour in May (you can tell from the topic concentration where my mind has been!):
  Happy Scouring!
  
  - Evan
3. 🔗 anthropics/claude-code v2.1.161 release
  What's changed
  - OTEL_RESOURCE_ATTRIBUTES values are now included as labels on metric datapoints, so you can slice usage metrics by custom dimensions like team or repo
  - claude agents rows now show done/total before the detail when work is fanned out; peek shows the longest-running item
  - /mcp now collapses claude.ai connectors you've never signed in to behind a "Show unused connectors" row
  - Parallel tool calls: a failed Bash command no longer cancels other calls in the same batch — each tool returns its own result independently
  - Fullscreen mode: clipboard now uses wl-copy/xclip/xsel on Linux when available, copies to both the clipboard and PRIMARY selection for middle-click paste, and the "hold {key} for native selection" hint now shows the correct key per terminal
  - Fixed the /effort dialog, workflow animations, and prompt keyword shimmer not honoring the "Reduce motion" setting
  - Fixed forceLoginOrgUUID/forceLoginMethod managed-settings policies blocking third-party provider sessions (Bedrock, Vertex, Foundry, Mantle) alongside the org pin (regression in 2.1.146)
  - Fixed background subagent output corrupting claude -p stdout when using --output-format text or json
  - Fixed /usage-credits starting a re-login for Team and Enterprise admins instead of pointing to the organization's usage settings page
  - Fixed /autofix-pr reporting "cannot run on the default branch" when the session is inside a git worktree or another repository
  - Fixed --resume picker not showing sessions from the current directory when it isn't a git worktree (e.g., jj workspaces)
  - Fixed Windows hooks that invoke bash explicitly (e.g., /usr/bin/bash script.sh) failing with "command not found" or "cannot execute binary file"
  - Fixed OpenTelemetry log events (user_prompt, api_request, tool_result, tool_decision) being silently dropped when emitted before telemetry initialization completed
  - Fixed claude mcp list/get/add printing secrets to the terminal: ${VAR} references are no longer expanded, and credential headers and URL secrets are redacted
  - Fixed Workflow agents spawned with isolation: "worktree" in background sessions being blocked from editing files inside their own worktree
  - Fixed background sessions dispatched from claude agents booting on a stale model from the daemon's environment instead of the model in settings.json
  - Fixed a potential crash when rendering Write tool results after resuming a session
  - Fixed completed subagents getting stuck showing as running when an error occurs while finalizing their result
  - Fixed EADDRINUSE errors from tools that bind Unix sockets under $TMPDIR when CLAUDE_CODE_TMPDIR is set to a deep path
  - Improved terminal rendering performance by stabilizing the layout engine's JIT compilation profile
  - Improved rendering performance for large file writes
  - [VSCode] Added a tip suggesting disabling terminal GPU acceleration (or running /terminal-setup) to fix garbled glyphs
4. 🔗 streamyfin/streamyfin v0.54.1 release
  What's Changed
  
  ✨ Highlights
  - MPV player on Android & iOS with hardware decoding and PiP (with subtitles) (#1332), plus native Apple controls (#1411) and MPVKit 0.41 (#1604)
  - Chapter markers and chapter list in the player (#1586)
  - Local network auto-switch — automatically switches to your local server address (#1334)
  - TV interface overhaul — uniform scaling, tvOS TopShelf extension (#1561), Android TV recommendations (#1575), and iOS TV builds enabled (#1422)
  - Setting to disable auto-play next episode (#1342)
  - Autorotate for landscape (#1265)
  🎬 Player
  - Caching progress shown in the seek bar (#1376)
  - Progress throttling for MPV (#1366)
  - Fixed progress bar / watch-time reporting (#1611, #1239)
  - SubRip subtitle fixes for MPV (#1375)
  - Stop external subs from auto-selecting when added (#1349)
  - Disable subtitle embedding on iOS simulator (#1544)
  - Don't cache background media-source requests (#1602)
  - Android PiP fixes (#1605, #1628)
  - Keep landscape when opening chapter list on iOS (#1624)
  📺 TV
  - TV menu/back navigation and overlay focus fixes (#1559, #1558)
  - TV password modal fix (#1598)
  - TV native search component
  🐛 Fixes
  - Music videos and home videos now show in libraries (#1326)
  - Close modal on Android back button (#1487)
  - Clear stored user on logout (fixes empty home on relaunch) (#1622)
  - Dedupe top people sections (#1623)
  - Correct mimeType/UTI for log export (#1424)
  - Downloads refactor — less prop drilling, improved layout (#1337)
  🔧 Build & Infra
  - Expo SDK 55 → 56 upgrade (#1594, #1600)
  - iOS 26 / SDK 56 EAS build fixes (#1613)
  - Android MPV Kotlin build fix (#1614)
  - EAS build + auto-submit release workflow (#1616, #1632)
  - Xcode build script (#1296)
  🌍 Translations
  - Ongoing Crowdin sync; new strings for "ends at" and action sheet options; Russian updates (#1474, #1475, #1427)
  👋 New Contributors
  
  @quang-tran, @gallyamb, @a-collado, @stevebyatt10, @felixschndr, and @github-actions[bot] made their first contributions.
  
  Full Changelog : v0.51.0...v0.54.1
5. 🔗 sacha chua :: living an awesome life La semaine du 25 au 31 mai rss
  lundi 25
  
  mardi 26
  
  mercredi 27
  
  jeudi 28
  
  vendredi 29
  
  samedi 30
  
  dimanche 31
  lundi 25
  
  Ma fille était un peu triste parce que j'avais mangé mon petit-déjeuner avant qu'elle ne se réveille. Elle m'a demandé si je pouvais l'attendre pour que nous puissions manger ensemble.
  
  J'ai emmené ma fille chez l'oculariste pour polir sa prothèse oculaire. Après le rendez-vous, elle a voulu rentrer au lieu d'aller chez College Optical pour commander des lunettes de soleil correctrices.
  
  Pour le déjeuner et en guise de récompense pour le rendez-vous chez l'oculariste, nous avons mangé des nouilles instantanées. Ma fille m'a donné l'autre moitié de son sachet d'épices aux fruits de mer. Nous les avons enrichies avec du gâteau au poisson et aux algues. Elle a découvert qu'elle n'aimait pas le mochi à la crème glacée, donc elle a eu de la crème glacée à la place.
  
  Après l'école, elle n'a pas voulu aller au cours de gymnastique parce qu'elle était un peu fatiguée. Au lieu de cela, nous sommes allées au parc pour jouer avec une balle, une corde à sauter, un grand dé en mousse, et la pataugeoire là-bas.
  
  Pour le dîner, ma fille a voulu du sushi au crabe comme au restaurant que nous avons essayé vendredi.
  
  Mon mari, ma fille et moi avons joué au Scrabble. Maintenant ma fille peut trouver ses propres mots avec quelques indices. Nous avons joué juste pour le plaisir, donc nous n'avions pas compté les points. Pour notre premier jeu, elle a voulu échanger des tuiles avec mon mari et moi, donc nous le lui avons permis. Pour notre deuxième jeu, mon mari a dû aller faire autre chose, donc elle et moi avons joué. Elle a voulu inclure les noms Pokémon, donc nous nous sommes amusées en plaçant les mots comme « Ekans », « Abo » et « Jolteon » (l'anglais et le français sont également permis) même si les mots anglais normaux sont aussi possibles.
  
  mardi 26
  
  J'ai terminé la transcription de ma conversation avec Matei qui est anthropologue. Je la lui ai envoyée pour relecture avant de la publier.
  
  Un des chats de notre voisinage m'a rendu visite, donc je lui ai donné un bol d'eau.
  
  Ma fille et moi sommes allées au parc pour jouer seules. Nous avons joué avec la balle et à la pataugeoire.
  
  J'ai appris que la prononciation du verbe « interviewer » en français a deux sons « v ». C'était intrigant.
  
  mercredi 27
  
  L'école a eu un remplaçant, donc elle a choisi de sécher les cours. Le matin, elle et moi avons travaillé sur ses devoirs dehors. Elle était de bonne humeur. L'après-midi, elle était un peu triste parce qu'elle attendait une réponse de son amie, et elle s'est blottie sur le canapé. Une fois qu'elle a finalement reçu une réponse, j'ai emmené ma fille au parc pour jouer avec ses amies. Elle s'est très amusée, donc j'ai eu vraiment du temps pour penser pendant qu'elle jouait.
  
  J'ai finalement envoyé les factures pour le mois de mars et d'avril.
  
  Ma mère est restée à la maison parce qu'elle avait fait une petite chute.
  
  jeudi 28
  
  J'ai discuté avec Protesilaos sur les recommandations sur Emacs pour divers utilisateurs.
  
  Ma fille et moi avons joué au Scrabble sur le porche pendant la pause déjeuner. Nous avons aussi joué au Scrabble avec mon mari après le dîner. Nous avons commencé à compter les points, bien que nous ayons toujours joué en coopération.
  
  vendredi 29
  
  J'ai interviewé Omar Antolin Camarena sur sa configuration et ses flux de travail sur Emacs. J'ai travaillé sur la publication des transcriptions vers le format PDF. J'ai ajouté la fonctionnalité d'exclure des sections par format selon les étiquettes.
  
  J'ai pratiqué la prononciation française.
  
  J'ai emmené ma fille à un cours de rattrapage de gymnastique aérienne.
  
  samedi 30
  
  Ma fille s'est amusée toute seule à faire des bulles et à jouer avec de la mousse à raser.
  
  Ma fille a voulu des vêtements neufs et un jouet anti-stress, donc je l'ai emmenée dans différents magasins. Elle n'a pas aimé le Thinking Putty au début qu'elle a choisi parce qu'il a des paillettes. Nous sommes prudentes avec les paillettes pour éviter de gratter son œil si elle le frotte. Après avoir joué avec le Putty, elle a décidé qu'elle l'aime, et elle va simplement bien se laver les mains.
  
  Pour explorer de nouvelles saveurs, nous avons mangé chez KFC.
  
  Pendant qu'elle regardait des émissions, j'ai ajouté une commande à mon logiciel pour effacer des images incorrectes afin que j'en téléverse une nouvelle.
  
  Nous avons joué à Donjons et Dragons ensemble pour nous exercer au rôle de meneuse de jeu. Mon roublard halfelin a vaincu un méphite, mais le mimique dans l'autre pièce était trop pour moi. Du côté de ma fille, elle a aidé Cornflower avec les devoirs de la ferme.
  
  Mon mari et moi avons discuté des voyages. Même si voyager est bien recommandé pour se découvrir soi-même, il y a d'autres façons de le faire, donc il vaut mieux bien réfléchir. Pour le moment, je pense qu'il vaut mieux que j'aide ma fille à apprendre à apprécier ce qui est proche.
  
  Ma fille a dit qu'elle a du cérumen, donc elle a utilisé de l'huile minérale pour le déloger. Ça a marché.
  
  Après le dîner, j'ai fait les courses seule.
  
  dimanche 31
  
  Mon mari était trop frustré aujourd'hui, donc mon mari et ma fille étaient tous les deux grincheux. Je me demande ce qui se passe.
  
  Quand même, pendant qu'ils se débrouillaient, j'ai travaillé sur les transcriptions de mes entretiens récents. J'ai aussi poussé des mises à jour de mon outil pour écrire le sous-titrage. J'ai oublié de vérifier mes changements avec les tests, mais heureusement, il y avait juste un bug et le bug était dans le test au lieu du code. J'ai aussi restauré les articles que j'ai accidentellement effacés. Ensuite, j'ai recherché des machines à coudre pour ma sœur et mes nièces qui habitent aux Pays-Bas, parce que leur ancienne machine était abîmée.
  
  Ma fille s'est très amusée en jouant comme la meneuse de jeu dans un jeu de Donjons et Dragons avec sa tante. Elle veut être la meneuse de jeu pour un jeu avec ses tantes et ses cousines la semaine prochaine, donc sa tante lui a offert l'occasion de s'entraîner.
  
  J'ai appelé ma mère. Elle m'a dit que ma tante lui demandait à plusieurs reprises si nous lui rendrions un jour visite. Eh ben, ma tante ne nous aidera pas à élever notre enfant si je suis malade, donc son opinion ne compte pas pour moi.
  
  View Org source for this post
  
  You can e-mail me at sacha@sachachua.com.
6. 🔗 sacha chua :: living an awesome life La semaine du 18 au 24 mai rss
  lundi 18
  
  mardi 19
  
  mercredi 20
  
  jeudi 21
  
  vendredi 22
  
  samedi 23
  
  dimanche 24
  lundi 18
  
  Je me suis réveillée très tôt pour interroger ma sœur qui est très malade d'un cancer. Nous voulons enregistrer des vidéos pour ses jeunes filles et son mari. Sa fille aînée a commencé à l'interviewer, mais bien sûr, il y a des sujets dont elles ne peuvent peut-être pas parler pour le moment. Je l'ai appelée sur Facebook Messenger et j'ai utilisé OBS pour enregistrer l'appel. J'ai un flux de travail pour corriger et formater la transcription, et je suis ravie de l'utiliser pour ma famille.
  
  Il faisait très chaud. C'était notre première vague de chaleur intense cette année. J'ai emmené ma fille au parc Amos Waites pour jouer à la pataugeoire là-bas. Elle a vraiment aimé la robe-maillot que nous avons cousue. Elle adorait tourner dans le siège pivotant que notre parc à proximité n'a pas. Elle a tellement joué qu'elle s'est endormie sur le chemin du retour.
  
  Après le dîner, ma fille et moi sommes allées à un autre parc pour regarder des feux d'artifice pour la fête de la Reine. Il y avait beaucoup de gens, donc je pense que c'était un rassemblement habituel pour les jours de fête où les feux d'artifice sont autorisés.
  
  J'ai terminé la révision de la transcription de ma conversation avec Prot et Philip. Je pense que l'audio de Philip est parfois trop faible, mais je ne suis pas sûre de pouvoir normaliser juste ces segments. Si j'ai une conversation avec un autre locuteur, je peux enregistrer les flux audio séparément, mais dans une conversation entre trois locuteurs (Prot, Philip et moi), je ne peux pas complètement les séparer. En plus, je pense que je ne peux pas remplacer juste l'audio d'une vidéo en diffusion sur YouTube. Peut-être que je peux mettre en ligne une nouvelle vidéo et changer l'ancienne vidéo en une vidéo non répertoriée.
  
  À l'heure du coucher, ma fille et moi avons parlé de la neurodivergence, des mathématiques, et des facteurs humains comme les limitations de la boucle auditive comparée à la visualisation. J'adore lui parler de son cerveau.
  
  mardi 19
  
  J'ai essayé de virer de l'argent aux Philippines via Wise. C'était réussi.
  
  Je me suis entraînée aux virelangues. Oups, j'ai oublié de confirmer l'audio sur OBS, donc je ne peux pas l'analyser.
  
  J'ai réécrit deux transcriptions pour les entretiens de ma sœur.
  
  J'ai emmené ma fille au parc pour jouer avec ses amies. J'ai oublié les glaces à l'eau, donc je suis revenue à la maison pour les retrouver.
  
  Nous avons pratiqué les permutations et la division posée.
  
  mercredi 20
  
  J'ai réécrit encore des transcriptions pour les entretiens de mes nièces avec ma sœur. J'ai configuré un serveur dans notre réseau pour les héberger avec l'authentification basique.
  
  L'école avait un remplaçant aujourd'hui. Il a accidentellement éjecté tous les élèves de la salle de réunion virtuelle et tous ont dû attendre que l'enseignant corrige les permissions.
  
  J'ai ajouté un gousset aux shorts de bain de ma fille.
  
  J'ai emmené ma fille et son amie au parc pour jouer. Elles se sont amusées à me donner des décharges avec l'électricité statique. Après que les autres amies de ma fille sont arrivées, ma fille semblait un peu surstimulée. Elle est partie seule et elle était grincheuse pour le reste de la journée, pauvre chérie.
  
  jeudi 21
  
  J'ai discuté d'Emacs avec Raymond Zeitler sur une diffusion en direct. C'était la première fois que je lui parlais en vidéo même si nous correspondons depuis 18 ans via les commentaires sur mon blog.
  
  Le dentiste a fait deux plombages. Il a proposé un plan de traitement, mais c'est cher, donc je veux bien y réfléchir avant de procéder. Je pense que je veux gagner en confiance avec ce dentiste d'abord. On dirait que la restauration précoce est mieux que d'attendre pour les dents cariées selon les recherches, donc c'est bon, mais on dirait aussi que d'autres dentistes recommandent d'autres niveaux de traitement. J'aime les précautions COVID que ce dentiste prend. Il y a d'autres dentistes (un peu loin) qui prennent aussi ce niveau de précautions, mais ils disent probablement la même recommandation (c'est la même recherche), donc je ne cherche pas particulièrement d'autre conseil. Je ne veux pas passer pour une vache à lait, tu sais?
  
  vendredi 22
  
  Je me suis réveillée tôt pour une conversation sur la communauté Emacs et l'IA avec Matei Candea, un anthropologue. Il pense à faire une étude ethnographique, et je pense que c'est potentiellement intéressant.
  
  J'ai terminé la transcription de ma conversation avec Raymond Zeitler sur Emacs. J'ai remarqué que j'utilisais le mauvais horodatage pour publier les chapitres à partir de la transcription, donc j'ai corrigé l'erreur.
  
  Ma fille n'a pas voulu participer à l'école parce qu'il y a eu un remplaçant, donc elle a fait une pause.
  
  J'étais fatiguée, donc j'ai fait une sieste.
  
  J'ai emmené ma fille au cours de rattrapage de gymnastique. Elle a pris plaisir à apprendre la gymnastique aérienne. Après le cours, ma fille a voulu aller au parc asperge (St. James Park) parce qu'il y a un grand toboggan. Elle s'est entraînée à descendre le toboggan à de nombreuses reprises. Après avoir fait ça, nous avons acheté du sushi. Elle a essayé la tempura de crevettes et elle l'a aimée.
  
  samedi 23
  
  Il a beaucoup plu et c'était très venteux, donc nous sommes restées à la maison au lieu d'aller à la célébration de printemps à la ferme Riverdale.
  
  Ma fille et moi avons joué à Stardew Valley avec le mod Tileman Reworked, qui me demande d'acheter les tuiles auxquelles je veux accéder. J'aime parfois jouer à des jeux avec des limites comme Minecraft Skyblock parce que les limites focalisent l'attention et la progression est très différente. Ma fille préfère notre jeu précédent avec le mod Stardew Valley Expanded.
  
  Pour le dîner, nous avons mangé du sotanghon, qui est une soupe aux nouilles et au poulet. Nous avons aussi essayé le taiyaki congelé. C'était pratique et acceptable, mais bien sûr le taiyaki chez Pat Mart est meilleur.
  
  À l'heure du coucher, ma fille et moi avons discuté de la neurodivergence, de la double exceptionnalité, de l'apprentissage des élèves doués, de la différence entre la récupération d'information et de la synthèse. Nous avons aussi discuté de la faune, des maladies, des vaccins, et d'autres sujets.
  
  dimanche 24
  
  J'ai parlé avec mon mari du TDAH. Il pense que je suis juste préoccupée, et ce n'est pas grave. C'est bon. Je ne veux pas laisser ma vie être perturbée au point d'avoir des problèmes dans deux zones ou plus dans ma vie pour obtenir possiblement un diagnostic, ce qui ne m'aiderait probablement pas beaucoup plus. Quand même, je peux continuer d'explorer comment je peux m'adapter à mon cerveau et ma situation.
  
  Ma fille et moi avons préparé du lait au sucre brun et aux perles boba faites à la main.
  
  Mon mari, ma fille et moi sommes allés aux Stockyards pour faire des courses. Nous avons acheté une boîte de mangues, des perles boba, des haricots azuki, et d'autres aliments. Nous avons préparé une fournée de mochis aux haricots azuki.
  
  J'ai recherché quelques dessins pour les transcriptions. Je pense que je veux inclure les noms des interlocuteurs dans la marge gauche et les horodatages dans la marge droite. Je veux aussi réécrire la transcription pour supprimer les mots de remplissage.
  
  Pour le dîner, nous avons mangé du curry japonais.
  
  Je me suis couchée tard parce que sur Stardew, j'ai finalement accédé à la caisse chez Pierre pour acheter des graines dans la troisième année. La progression est très lente. Heureusement, le mod HibernationRedux me permet de sauter le temps pendant que j'attendais la croissance des arbres.
  
  View Org source for this post
  
  You can e-mail me at sacha@sachachua.com.
7. 🔗 r/reverseengineering Resident Evil: Code Veronica X is now able 3D graphics from the decompiled source! rss
  
  submitted by /u/MrFroz1995
  [link] [comments]
8. 🔗 r/LocalLLaMA Minimax M3 appears to have no political censorship rss
  
  | I'm currently working on a chinese/CCP AI bias benchmark, and this has stood out as an outlier. All the other Minimax models are censored as is typical for chinese LLMs. submitted by /u/DingyAtoll
  [link] [comments]
  ---|---
9. 🔗 Register Spill Building Software Is Learning rss
  A few weeks ago I shared the following as an internal message with the Amp team. I showed it to a friend while talking about feedback loops and he told me to post this publicly. So here we go. Unedited, straight up copy & pasted from our Slack.
  
  You know what's rare?
```
person a: "we need this feature"
person b: "yes, let me build it"
...
person b: "done."
person a: "fantastic, exactly what I wanted."
```
  That's basically NEVER what happens. At least not when you're building something new. It might happen when you fix a bug or when you port something that already exists in another app to a new language or framework, ... Or when you're building after a spec.
  
  But when there's no spec, and when you're building something new?
  
  Here's how that works:
```
person a: "we need this feature"
person b: "yes, let me build it"
[...]
person b: "done."
person a: "hmm, actually, that's not what I meant. what I meant is: [...]"
```
  Or this:
```
person a: "we need this feature"
person b: "yes, let me build it"
[...]
person b: "you know what... There's 3 ways to do this, actually, and I'm not sure what the best way to do this is?"
person a: "ah, I see, I think given that we want to ship this tomorrow, let's go with way 1"
```
  Or:
```
person a: "we need this feature"
person b: "yes, let me build it"
[...]
person b: "done."
person a: "Don't like it"
```
  Now why does that happen, again and again and again?
  
  Because building new software is learning! If you're building something new and you don't yet fully know how exactly it's supposed to work, you will learn what exactly it is that you're building as you're doing it. Let me repeat: building new software is learning.
  
  So far, so good, right? But here's the very important bit, the one bit I want you to take with you into this week: there is no way in hell , absolutely zero chance, that you can build something new and avoid bumping into "that's not what I meant", or "now that I'm working on it I'm not actually sure", or "hmm, now that I use it, I don't like it". Because the only way you could avoid that would be to fully specify what you want up front and, well, guess what programming is? It's fully specifying what you want. You can't avoid it, because you can't define it yet, because building software is learning!
  
  Now that was the bad news. Here's the good ones. You can reduce the time the ... from the examples above takes -- the time between the confident "yes, let me build this" and the humbled "oh, I see".
  
  And that, in turns out, is the most important thing you can do when you're building something new: reducing the time it takes you to go from "let me try something" to getting your ass whooped by reality.
  
  If someone says "we need this feature", don't go "yes, let me build it" and hack on something for 4 weeks only for the other person to ultimately go "that's not what I meant." No. Instead, embrace that we need to learn , that we need to try and play around with this idea as fast as possible, in a way that lets us learn. To embrace that idea means that you try to figure out "what is it they mean" as fast as possible , with the minimal effort required, so you can LEARN what it is you're building.
  
  Instead of going away for 4 weeks and hacking on something, you instead can do stuff like this:
  - ... build a prototype, in 1hr, and show it to them, and they go "no, that's not what I meant, you should change this part here"
  - ... write down a spec of how you'd approach it, in 30min, and show it to them, and they go "no that's not what I meant"
  - ... cut up the thing in multiple things and ship one every day, so that every day what you built hits reality and you get to learn, because on day 2 someone says "know what, we should change..."
  - ... reduce the scope, figure out what the things are that we're already sure about and skip those, and instead focus on the bits that we don't know yet -- that's where we need to learn. don't add 5 ways to login, if all we need to learn right now is 1.
  - ... fake a demo video, show that around, get input on that - Quinn's done it many times
  - ... write the news post that explains the idea -- why waste effort building something for a week if the idea can be captured in 3 paragraphs?
  - ... write the example code that would go into the README, show that around, does that look like a good API? People don't need an SDK built if they dislike the API in the readme.
  - ...
  There's more options that I didn't list here. And you don't have to pick only one. In fact, for something big, you should probably do a few of these things. Or you vary them, or combine them, or ...
  
  What exactly you do doesn't matter as much as constantly asking: how can I get feedback on what I'm trying to build as soon as possible? And "feedback" here is used in the widest sense possible. Feedback comes in all shapes and sizes: feedback from the CI system on main, feedback from colleagues, feedback from users, feedback from you once you actually use it.
  
  And if you follow that question -- how can I get feedback as soon as possible, so I can learn? -- you'll also find out how to chop things up and how to ship them:
  - you won't get good feedback if you ship an "MVP" of an idea that's so obviously buggy that all you'll get is bug reports for 3 days, not actual feedback on how useful it is
  - you won't get good feedback if the people supposed to give you feedback have to jump through 8 hurdles to test it
  - you won't get good feedback if you keep your changes on a branch for 3 weeks, because by the time you merge your 27 commits and CI blows up you have 27 possible causes, vs. 1 if you had merged them one by one
  - want feedback on the design of your skateboard? sure, show them the deck, no need for wheels. want feedback on how your skateboard feels? you can't ship it to testers without wheels on it.
  - ...
  So. Here's what I want you to think about going into this week: how can I get feedback on what I'm building on as fast as possible? when is the last time I got valuable feedback on what I'm building? in what frequency do I get feedback on what I'm building? why is that frequency so low?
  
  Because we're building something new, in a time when software is changing (background vocals: everything is changing), and no one has a clue what the fuck is going on - so the most important thing is to embrace that and as soon as possible, as often as possible, ship things on which we can get feedback on, in a way that gives us valuable feedback -- by CI, by production, by our teammates, by select users, by select customers, by all of our users.
  
  Yes, italics and bold. Because building software is learning and we want to learn as much as possible.
  
  Like italics and bold? Subscribe:
10. 🔗 r/LocalLLaMA I have become George Jetson: my job is now Yes/No supervision for a machine I don’t fully understand. rss
  
  | submitted by /u/Helpful_Today7449
  [link] [comments]
  ---|---
11. 🔗 r/reverseengineering Built a decompiler for exotic legacy programming language opentext Gupta Team Developer rss
  
  submitted by /u/Sita-Technologies
  [link] [comments]
12. 🔗 anthropics/claude-code v2.1.160 release
  What's changed
  - Added a prompt before writing to shell startup files (.zshenv, .zlogin, .bash_login) and ~/.config/git/, which could otherwise lead to unintended command execution
  - acceptEdits mode now prompts before writing build-tool config files that grant code execution (.npmrc, .yarnrc*, bunfig.toml, .bazelrc, .pre-commit-config.yaml, .devcontainer/, etc.)
  - Edit no longer requires a separate Read after viewing a file with grep: single-file grep/egrep/fgrep commands now satisfy the read-before-edit check
  - Fixed copy-on-select not writing to the Windows clipboard on WSL — now uses PowerShell interop instead of OSC 52, which terminals like MobaXterm don't support
  - Fixed restoring a completed session from claude agents dropping chat history and re-running the original prompt
  - Fixed background sessions re-attached after overnight retire losing their conversation and re-running the original prompt
  - Fixed claude --bg occasionally failing with "socket missing" when the background daemon was cold-starting on a loaded machine
  - Fixed an issue on Windows where the directory a background session was started in could not be deleted after claude rm until the background daemon exited
  - Fixed background agents that resumed work being shown under Completed in the agents list
  - Fixed claude agents freezing for several seconds when returning to the session list due to the auto-updater re-checking on every exit
  - Fixed Esc, arrow keys, and typing becoming unresponsive on Windows when attached to a background session or in the agent view while the host is under heavy CPU load
  - Fixed background agents emitting terminal sync-output markers to terminals that don't support them (Apple Terminal, tmux), causing render artifacts when entering a running agent
  - Fixed mouse wheel scrolling prompt history instead of the transcript right after opening a session from the agents list
  - Fixed CJK IME composition appearing at the bottom-left of the screen instead of at the input caret in the claude agents view
  - Fixed valid file:///C:/... links being rewritten to a broken path on Windows terminals with hyperlink support
  - Fixed voice mode failing to connect when the project directory or branch name contains non-ASCII or special characters
  - Fixed the auto mode unavailability message on third-party providers (Bedrock/Vertex/Foundry) to point to the CLAUDE_CODE_ENABLE_AUTO_MODE opt-in instead of incorrectly blaming the model
  - Fixed /effort ultracode incorrectly blaming the dynamic workflows setting when the model cannot run xhigh; ultracode is no longer offered on models that do not support it
  - Fixed model-not-found errors suggesting --model when running via the SDK or other hosts where the CLI flag doesn't apply
  - Fixed Claude's past replies disappearing from scrollback when resuming a brief mode session with brief mode turned off
  - Fixed vim mode p pasting on the line below instead of at the cursor when the register was yanked with v$
  - Improved performance of opening recently-inactive background agent sessions in claude agents
  - Improved auto mode classifier latency by reducing reasoning on routine actions, lowering the chance of "could not evaluate this action" blocks
  - Improved background-session teardown (claude rm/stop, idle reap) to send SIGTERM to running shell subprocesses before SIGKILL, so cleanup handlers run
  - Removed CLAUDE_CODE_OPUS_4_6_FAST_MODE_OVERRIDE; the environment variable is now a no-op
  - Removed the JetBrains plugin install suggestion from startup
  - Renamed the dynamic-workflow trigger keyword from workflow to ultracode. The word "workflow" no longer triggers a run; asking for one in your own words still works. The trigger keyword is highlighted in violet in the prompt input
13. 🔗 Rust Blog Launching the Rust Foundation Maintainers Fund rss
  If you want to financially support the development of Rust, please consider donating to the Rust Foundation Maintainers Fund.
  
  A few months ago, the Rust Foundation announced the Rust Foundation Maintainers Fund (RFMF). Since then, the Rust Project has been closely cooperating with the Rust Foundation to determine how exactly this fund will be used to support Rust maintainers. This resulted in the acceptance of RFC #3931, which established the Funding team and the Maintainer in Residence program.
  
  The primary goal of the Funding team is to ensure that maintainers who work on Rust and its toolchain will be properly supported. We will talk to Rust Project members to figure out their funding situation, meet Rust team leads to learn about their maintenance needs, approach companies to find opportunities for them to invest into Rust by supporting Rust maintainers, coordinate various funding efforts and ensure that the beneficial effects of funded maintenance are visibly promoted, with the help of the Content team.
  
  Maintainer in Residence is a new program dedicated to financially supporting existing Rust Project maintainers1. Each Maintainer in Residence will be funded to maintain one or more critical parts of Rust, such as the compiler, the standard library, Cargo, Clippy or one of many other projects that the Rust Project develops and maintains. The funded work will include activities such as performing large-scale refactorings, code reviews, unblocking new features, issue triaging, mentoring other contributors and more, and will be split between priorities guided by the teams they are supporting and priorities of their own choosing within the Project. Where applicable, Maintainers in Residence are also encouraged to propose, champion, and drive forward Rust Project Goals.
  
  The goal of this program is to provide stable and long-term funding so that maintainers can focus on important work that ensures the long-term health of Rust. The funding team will select Maintainers in Residence based on funding availability and maintenance needs within the Rust Project, and help ensure that they are successful. We expect that this will usually be a (near) full- time position, but that will depend on the nature of the work and the area of maintenance.
  
  This program extends our existing support for Rust maintainers, such as the program management program and the compiler-ops program. An important development is that we now have a centralized mechanism for gathering donations from both individuals and companies, and a dedicated team that will help direct those funds to specific maintainers. You can find more details about the funding team and the Maintainer in Residence program in the RFC.
  
  We expect to hire the first Maintainer in Residence in the upcoming months and announce it on this blog, so stay tuned!
  
  How to contribute funds
  
  If you are an individual who wants to help Rust succeed and thrive, you can donate to the RFMF through GitHub Sponsors 2. Companies who would like to invest in better maintenance of Rust can also donate through GitHub Sponsors or they can contact the Rust Foundation directly.
  
  The important thing is that all proceeds from this fund will be directly used to support Rust Project maintainers. We currently expect that to happen primarily through the Maintainer in Residence program, but it can also be done in the form of smaller-scale grants or other mechanisms, as determined by the Funding team. We will figure this out on the go, as this is also quite new for us.
  
  We really appreciate each donation, however small, because with more money we can hire more maintainers to ensure that we can continue to develop Rust and that important improvements are not blocked on maintenance tasks. This is especially important at this time, where Rust is starting to get used more and more in the industry in various application areas, which increases the need for sustained maintenance. The importance of multiple funding sources is underscored by an unfortunate trend we currently observe, where key Rust maintainers are losing their funding for Rust work due to budget shifts. The Rust Foundation Maintainers Fund is designed to provide stable funding for Rust maintainers that is less dependent on sudden shifts in the job market and the IT industry.
  
  As with most things, there is no one-size-fits-all solution, so there are multiple ways to support Rust financially. The RustNL Maintainers Team recently hired several Rust Project maintainers. Previously, we wrote about how you can support specific individuals working on Rust. And there are also Rust Project Goals in search of funding. We welcome all efforts that can help support Rust Project maintainers, who often do work that is near invisible and thankless, while at the same time incredibly important and necessary, on a volunteer basis.
  
  Thank you for considering sponsoring the development and maintenance of Rust! You can find more information about funding Rust on our Funding page.
  1. This program was inspired by the Developer in Residence concept used by the Python Software Foundation (PSF), with which we led several helpful discussions. Thank you, PSF! ↩
  2. Note that the fact that GitHub Sponsors is currently enabled on the rustfoundation GitHub organization, and not the rust-lang organization, is an implementation detail that might change in the future. All donations raised on this Sponsors page will be routed to the Rust Foundation Maintainers Fund and will be spent on directly supporting Rust Project maintainers. ↩
14. 🔗 Ampcode News The End of Public Threads rss
  
  We’ve removed public, internet-wide, discoverable thread sharing from Amp. You can still share threads within a workspace, or as Unlisted to share them with anyone by unguessable URL.
  
  Why? It’s getting too hard to review a thread to ensure it doesn’t contain any snippets of sensitive files. Each model release means the agents get better, and as they get better they read more files into context. Public discoverable thread sharing is just too risky now. This decision is proactive and isn’t prompted by any incident.
  
  Public discoverable threads have served their purpose well. Last year, Mitchell’s Ghostty threads and other publicly shared Amp threads helped spread the word that coding agents were actually good—and taught people how to use them.
  
  Public user profiles (like ampcode.com/@sqs) still show your activity but no longer show any threads. Any existing Public (Discoverable) threads are now Unlisted, so your blog posts with thread links won’t break.
15. 🔗 Drew DeVault's blog Vim Classic 8.3.0 released rss
  
  Following up on my earlier announcement that I was forking Vim, I’m happy to announce the first release of my fork today: Vim Classic 8.3.0.
  
  I have written a release announcement for vim-classic.org, which you can read here. Happy editing!
June 01, 2026
1. 🔗 IDA Plugin Updates IDA Plugin Updates on 2026-06-01 rss
  IDA Plugin Updates on 2026-06-01
  
  New Releases:
  - augur v0.9.2
  - haruspex v0.9.3
  Activity:
  - augur
    
    af5ab923: feat: prepare for release
    
    cd765425: doc: update CLAUDE.md
    
    ac69ea14: fix: remove the test step from windows and macos targets in ci
    
    10be4097: test: add cargo test to macOS and Windows CI workflows
    
    8b4fbaf5: fix: code formatting
    
    54105844: doc: commit CLAUDE.md
    
    ae180618: test: add integration test
    
    0c417c4f: refactor: extract an helper, use haruspex helpers, and add unit tests
  - haruspex
    
    b5e83c40: doc: update CLAUDE.md
    
    f34054f8: fix: remove the test step from windows and macos targets in ci
    
    3d7711be: test: add cargo test to macOS and Windows CI workflows
    
    d000bc58: test: add integration test
    
    acae1c08: feat: prepare for release
    
    d5405adf: feat: make helper functions public
  - idawilli
    
    89ac520f: Merge pull request #143 from williballenthin/claude/ci-failures-triag…
    
    586f20b2: Fix test collection: drop -import-mode=importlib
2. 🔗 r/LocalLLaMA Stop asking what model to run. There are literally only two. rss
  Can we please ban the daily "I have an RTX 3060, what should I run?" slop threads? It’s not complicated. As of right now, Hugging Face is empty and exactly two local models exist on this entire planet:
  - Qwen 3.6 35b a3b
  - Qwen 3.6 27b
  That is the entire list. Your specs don’t matter. Your use case doesn’t matter.
  
  Stop coping with your pristine, full-precision Q8s of tiny 1B models just because they "fit perfectly in your VRAM." You look ridiculous. Grab a heavily brain-damaged, ultra-low quant of the 35B, force-feed it to your GPU, and let your system RAM bleed. A garbage quant of a massive model is a bagillion times better than your precious micro-models anyway. Just cram it in.
  
  And if you're going to whine that open source is dead because a local model won't instantly rewrite your entire enterprise codebase? Fine. Give up, pull out your credit card, and go spend your money on Claude Code like the rest of the contrarians.
  
  Can we pin this so everyone can finally shut up and stop posting? Thanks.
  
  Now, that has been solved lets go touch grass.
  
  Edit: Damn I did not expect this to blow up, appreciate the people who actually got the bait. The comments coming from every which way reminds me of the time when reddit was not so sterile and buzzing before the bots showed up... made my day... I am going to be honest I totally expected to be downvoted to oblivion..
  
  BUT FOR REAL THERE IS ONLY TWO MODELS THAT EXIST.. I am looking at you Gemma.
  
  submitted by /u/Wrong_Mushroom_7350
  [link] [comments]
3. 🔗 benji.dog IndieWeb Book Club: June 2026 - Broad Band: The Untold Story of the Women Who Made the Internet by Claire L. Evans rss
  I am hosting this month's IndieWeb Book Club and I have chosen Broad Band: The Untold Story of the Women Who Made the Internet by Claire L. Evans.
  
  It's been a few years since I have read this book and I remember enjoying learning not only about the people involved but also some of their specific motivations behind their ideas, companies, and projects. I don't think this book is meant to be in any way a fully comprehensive on all the people involved which is why I'd also love to hear about any other people or stories that could work alongside this book as further reading material.
  
  To participate in the IndieWeb Book Club, write about this book and post it on your site. You can then let me know about your post either through email, webmention, or any other way to contact me you prefer.
  
  I will add all entries below as they come in.
  
  Additional Book Info
4. 🔗 r/reverseengineering running custom firmware / patching the stock firmware of the soundcore headphones and running DOOM on it! rss
  
  submitted by /u/NNonick
  [link] [comments]
5. 🔗 r/LocalLLaMA RTX Spark does not have 600GB/s Bandwith rss
  
  | Check the slides from Computex. Every outlet that reported 600GB/s is completely wrong. That is the NvLink speed like everyone here said. submitted by /u/rpiguy9907
  [link] [comments]
  ---|---
6. 🔗 @HexRaysSA@infosec.exchange By popular demand, we are extending our Spring Sale for our new on-demand mastodon
  
  By popular demand, we are extending our Spring Sale for our new on-demand starter training.
  
  This new training lets you go at your own pace and includes a handful of new practical exercises to sharpen your reversing skills.
  
  Get 20% off with code STR20.
  Offer expires 12 June 2026.
  
  https://hex-rays.com/training/ida-pro-starter-training
7. 🔗 Hex-Rays Blog What's new in the IDA Domain API? rss
  
  What's new in the IDA Domain API?
  
  It has been a while since our first post about the IDA Domain API, our *open- source* Python API designed to make scripting in IDA simpler, more consistent, and more approachable.
8. 🔗 sacha chua :: living an awesome life Transcript of chat with Matei Candea about Emacs and AI rss
  This is an edited transcript of my chat with Matei Candea, an anthropologist who is curious about the Emacs community and AI. Sharing it here with permission so that it becomes a thing I can refer to and in case it sparks further conversations. AI is a bit of a contentious topic, so I hope people will be patient and kind as we figure things out!
  
  Related links:
  Expand for the transcript
  
  NOTE Matei is an anthropologist; ethnographic research
  What I actually do for work is to do ethnographic research, to interview people. I've written a lot about scientific communities.
  For instance, I've written articles on behavioral scientists who work with animals and how they think about knowledge and technology and stuff. Completely independently of that, I kind of got into Emacs and got really excited. About four years later, I was, like, wait a minute, why don't I do an ethnography of Emacs as a community?
  Sacha: Really cool people.
  Matei: Right? Really cool people.
  Curious about Emacs as a community in the time of AI
  Matei: I think what I'm really saying is Emacs as a community in the time of AI and how that's shifting or not shifting how people are using it, and what it does. I've spoken to Prot on Monday. That was the first interview I did, and we had a great chat. I basically asked him how he got into Emacs and what it meant to him and what his relationship is to the community and stuff, and then a bit about AI and then a bit about what he feels are the interactions between the two.
  Matei: That's, broadly speaking, what I would be interested in doing with you.
  Matei: If you think there's a broader conversation, we could live stream and have an actual chat about how people use Emacs. By the way, I'm very happy also to tell you where my own trajectory was that I got into Emacs weirdly and randomly about a year before ChatGPT really hit the mainstream. The thing that you read by me was written because me and Ella together were trying to figure out Cambridge's response to AI as a university. Like, what are we going to do about it? If I'm going to be talking about that, I need to know how it works. But I don't want to use AI in my own actual work or in my teaching, because I think it's a bit dodgy. I don't really like it. Why don't I just do it with this kind of side project I've got, which is learning Emacs, right? And the weird paradoxical thing was that I now basically kind of live in Emacs. My email is mu4e. If you saw my screen now, the notes are basically a narrowed Org buffer with questions. Everything's email. But I don't think I could have got there that fast if it hadn't been for the fact that I started asking ChatGPT, like, "Oh, this isn't working. Can you just write me a defun that does this?" I'm not completely vibe coding. I'm trying to learn Elisp at the same time, but I'm in this weird position where... Anyway, this is why for me it raised these questions of: what does learning Emacs in the time of AI mean? As you can probably gather from the manifesto, I'm not pushing it at all. I'm really ambivalent about the use of AI. I find myself doing it and kind of sort of worrying about doing it. Would you be happy to do an interview like I did with Prot?
  Sacha: Yeah, we can certainly do that. In addition to whatever I can share from my personal experiences, I think your interest in understanding and describing the community and the culture and how it's interacting with this AI thing, I think it'll offer a perspective that is different from what you usually see, because Emacs users have had this long tradition of fiddling with things and making it really malleable and fitting it to them and figuring this out in dialogue. It's figuring out in dialogue with themselves as they figure out their workflows, with the software as they learn from the code, with other people, with resources on the internet not necessarily attached to specific people. That's got a really long history. It's really interesting to see how AI both has plus sides and minus sides in this whole mix. It definitely, I think, will offer some insight that you won't hear with the frothy AI hype that other communities have. It's all very interesting.
  Matei: Amazing. Let's start with a general kind of interview thing.
  How did I first get into Emacs
  Matei: How did you first get into Emacs?
  Sacha: I was going through all the books in my university library about computer science. One of them was Unix Power Tools. I was like, there's this chapter on Emacs, and it mentions Tetris and other things. What is going on here? I tried it. It was great. I liked it. Then in fourth year or so, my screen stopped working. I didn't want to replace it. But there was Emacspeak. I was amazed. Lots of people had put together Emacspeak so I could use the computer with a broken screen. I could still read it periodically, if I tilted it and kind of looked at the low contrast thing… The speech synthesis worked just fine. I'm going to program this way.
  Sacha: I'll plug into a monitor when I'm back in my room. But if I'm out and about, I have this other way to do it. Something that maybe most programs would not have anticipated, but because somebody had built it for themselves, it was something I could use. Before I got into Emacsspeak, I got into Planner Mode because I was a university student and I was taking notes. Planner Mode was an easy way for me to keep track of tasks. It was more flexible than other to-do managers.
  Sacha: It's one of the packages that was popular before Org Mode. I started using that to write my blog. Blogs had just been invented around then. I was figuring out, how do I export RSS out of this? I was able to customize it to do that. I liked it so much I emailed John Wiegley, who had created Planner Mode. I said, hey, I can help you fix bugs. He said, great, you're the new maintainer now. Which was actually very good for me because I was a university student in the Philippines, and Philippines, and normally we don't get to work on anything really cool. Suddenly I was in this global community of people. There was a mailing list. People would send in questions or feature requests. I would share the things that I was working on. They were very, very patient with me. Like that one time, one of my changes accidentally deleted somebody's notes and they were still nice to me afterwards. The community has always been part of how I experience Emacs. Learning in public has also always been part of how I've been figuring out what I can do with it and changing it to fit my needs, as very idiosyncratic as they are sometimes... It has also always been part of my experience of Emacs.
  Matei: When did this start?
  Sacha: Very shortly after I started Emacs, I started blogging with it. My first blog post from that is 2001.
  Matei: Right. You were studying computer science?
  Sacha: I was studying computer science, yes.
  Matei: Are you a computer scientist now? What do you do when you're not doing Emacs?
  Sacha: Most of the time, I'm still focused on full-time parenting, which is why I'm going over to the freezer now to remember to put yogurt in the freezer. I do a tiny, tiny, tiny bit of consulting, but consulting, but for the last 10 years or so, I've just been focused on parenting. Playing with Emacs and being in touch with the Emacs community has been one of the ways that I've kind of kept sane. I've enjoyed the intellectual puzzles of: I have this thing that I want to do, how do I do it with code in ways that I can fit into five minutes here, ten minutes there of my life.
  Matei: Do you do any other coding or just Elisp?
  Sacha: JavaScript, Python on occasion. Some of my consulting involves making little JavaScript prototypes for ideas that my client has, but it's really just an hour a week, maybe less. But for fun, I still write a bit of JavaScript and Python. Emacs Lisp, however, is what I usually write because it's so much easier to do things when you've got the full editor with you.
  Matei: Yes, that makes sense. I've got a million questions, but I'm going to try and do them in order. You've said a little bit about this already, but
  What do you love about Emacs?
  Matei: what do you love about Emacs?
  Sacha: You can come up with a crazy idea and you can actually make it happen. So, for example, I've been doing a lot of conversations, interviewing people or working with my sister's interviews. I always like turning these into text because text is a lot more searchable. Chapters and things like that too, right, so that people can jump to just the part they're interested in. I don't know how other tools do it, but I love the fact that I can modify Org Mode so that I can capture timestamps. Wall-clock time is easier for me to work with. I can say, okay, while I'm typing, I just use an abbreviation to put in the timestamp that's the current time and my rough notes. I have another piece of code that translates that into offsets from the start of the video based on YouTube's live stream or the file name of the video. Then I can paste that into the subtitle file so that it automatically puts the chapters in roughly the right places. As I come up with little workflow ideas, I can actually implement them.
  Community
  Sacha: I also love the community of it. Looking through the blog posts or as I put together Emacs News every week, there's always all these interesting examples from people who are asking the same questions about about "What is it I want to do?" and "How can I do it 0.5% better?" They write these little functions. I'm like, oh, that is a fantastic idea. I get to absorb that into my life. Because I'm seeing it in the context of their blog post or their video, you get a glimpse of other people's lives as expressed through code, because all of the code is very personal. That is one of the things that is good about the fact that people are using AI sometimes to generate this code. They can make things that things that punch above their weight. A newcomer to Emacs can have customized functions that let you fully appreciate its power. But on the other hand, if the AI is just generating this code, you don't get a sense of like, where's the blog post this is coming from? Or who would I talk to to keep up with other crazy ideas they come up with? You're limited to just your ideas. Then there's the whole thing about license-washing. Most of the people release their code under GPL because it's Emacs, but the large language models never mention that. They never say, you also have the right to go and share this and modify this and build on top of it and contribute back to the community. Anyway, it doesn't feel right, the code. It doesn't quite get the conventions and the idioms yet. So the things that I love about Emacs are generally the fact that it can fit me like a glove and it's got this community of people who are also exploring what is possible as crazy as ideas sometimes get. There's always some way to hack it in.
  Do you know how big the community is?
  Matei:
  Do you know how big the community is?
  
  Sacha: I have no idea. We generally feel like it's a lot smaller than VS Code and probably a lot smaller than Vim. It depends, of course, on if you're talking about percentage, it depends also on... There's a lot of Clojure developers using it, because it's the standard Clojure way of doing things, but there are probably a lot fewer Java or JavaScript people using it because a lot of people are in VS Code instead. I used to do Google Analytics tracking on my website, but I stripped all of that out because cookies and tracking and all of that. When people ask me how many people read this stuff, I have no idea, but I do know that every time I look for Emacs News, I'm delighted by the breadth that I come across. To me, it feels like there's a thriving community that's large enough for my interests.
  Matei: Cool. You're the second person I've actually spoken to. The first person was Protesilaos. I'm struck by the fact that from a sample of two, I've got two people who are not based in the US, who are super international, and also who are not developers.
  Sacha: That is a fantastic thing about it. I love that we have researchers and sourdough bakers and knitters. Of course, the programming part is still there, but a lot of people end up getting into some kind of programming because of Emacs. Emacs is the only thing they ever code, and they don't even think of it as coding. It's just like, I do this, but I wanted to be able to do this, so I learned how to do Org Mode and source blocks, and that's all I can do, but it's great. I think that's really interesting because when you talk to people about their origin stories with Emacs… Sure, of course, you have the pockets of people who are like, I'm a computer science student and my professor said use this, so I'm using this, and so forth. But then you get these random high school music students who are like, oh, yeah, I just saw this video and I thought it looked really cool, so I taught myself how to do that. I don't know anybody else who uses it in real life, but I like it. Musicians using it live to do performance... Where are these people coming from? But they come across it, and it just strikes a chord with them, deep in their souls. It appeals to a certain tinkerer type, I guess. They just continue with it. They get stuck. Sometimes they leave and they come back, and all that stuff… But the breadth is one of my favorite things about Emacs.
  Matei: Do you think that most of the people in the community are probably developers? Because when you were saying the community, you compared it to Vim and VS Code, which is to think of it really as an IDE kind of thing.
  Sacha: That's usually what people talk about, right? Because usually when people are thinking, how popular is this, they're stacking it up against developer tools because those are the surveys that the development websites do. Stack Overflow or State of Clojure or whatever. They'll ask people, “What editor do you use?” But given Emacs' surprising popularity among people who are, for example, diagnosed with ADHD and find that Org Mode is the only way they can manage their brains…
  Matei: Is that a thing? That's really interesting.
  Sacha: In a number of Reddit threads that I've seen, people are like, yeah, I'm not a programmer, but Org Mode is the only way that I've figured out how to manage my brain. Or people will come to Emacs from something else specifically for Org Mode because of the way that it can help them manage their tasks or agenda, because they can sculpt it to fit what their specific workflow could be. It's amazing. Of course, we've got the writers and the researchers who are like, "I love publishing beautifully typeset things, but I don't like working with LaTeX all that much, so let me just figure out the template once."
  Matei: Yeah, totally. I really came to Emacs because I was looking for an outliner. I'd been writing in Markdown for a while. I was really getting sick of the heavy Word stuff. And I was, like, Org Mode, omg, it's amazing! Then from there, I was bitten.
  Do you have any frustrations with Emacs?
  Matei:
  Do you have any frustrations with Emacs?
  
  Sacha: I would like to have more time in the day to fiddle with things. In terms of the balance between fiddling with my config and doing the thing that I want to do, if I sandwich it so that I do my 5 to 15 minutes of Emacs fiddling at the start, then I'm motivated to go through the task because I want to test that my improvement works. Then it becomes a good balance for me. I don't spend all the time feeling like I'm yak shaving, and I don't spend the time struggling with workflow because I didn't take the time to automate it.
  Sacha: I would like to have more time, because I always come up with more ideas in the middle of something. "I know this is possible. I just have to sit down and do it, and it'll be great. But okay, I have to wait till my next 5 to 15 minute window where I can fiddle with it again." The other thing that I've been trying to figure out is: how do you help people develop that intuition for how to do things, how to make Emacs do things? We see a lot of people come into the community. They might get stuck on some things. The tutorial is very useful, but it can be overwhelming. The whole Emacs thing can be very overwhelming for people. How you help people get through that part is something that's of great interest to me. Bringing it back to AI and large language models, the fact that people can sometimes have a conversation with this endlessly patient tutor where they might be too embarrassed to ask their questions on a mailing list or a forum, I think that's fantastic. But also, going to your manifesto's points about learning by doing and education and the eureka moment, we also don't want this quick and easy help to rob people of the understanding that they get from looking at it and tweaking the code or learning how to read through the source code themselves. There's just so much there that I would hate for people to just get stuck in the “please generate this code for me" level rather than be able to learn this is how I start learning from other people's source code so that I can come up with more ideas.
  Matei: That's right. That's also what I think basically. Here's an interesting question.
  Would you ever leave Emacs?
  Matei:
  Would you ever leave Emacs?
  
  Sacha: I cannot imagine an editor at the moment that would let me get away with nearly half of the things that I do, but maybe even less. Right now, I've got so many odd little customizations for it. For example, on my phone, I'll use Orgzly Revived to capture a quick note so that I can go back into Emacs later and do it. But even though I'm comfortable programming in JavaScript and Python, and there are lots of tools available there, the interactive interface part of things is something that I don't see any other program give me the same kind of platform of support or building blocks to play with. Who knows? If some day, this thing manages to support all of my hacks built on hacks and gives me that same kind of feedback loop, but it's also multithreaded and graphical and whatever, I might give it a try. But at the moment since I can get away with so much in Emacs and I know that people behind the scenes are working on adding even more to it, it's okay, long term. It's been around for 40 years. It'll be around for... Probably it'll outlive me. I don't have to worry too much about giving up on it.
  How important for you is the free software bit of Emacs?
  Matei:
  How important for you is the free software bit of Emacs?
  I was on Mac when I got into Emacs. I went to GNU Emacs to download it and it said, we made this available to people on proprietary systems in order to teach you to free yourself. I was like, huh? I downloaded it and I'm now running Arch Linux. It definitely worked. Richard Stallman has downloaded himself into my brain. How much is the free software bit of it important to you in using Emacs?
  Sacha: I'm not a purist. I will happily be the interface using the non-free things. For example, when we were doing EmacsConf, the first few years before Whisper was around, I was the one doing like, okay, fine, YouTube has this subtitling thing that we can grab the stuff from. Yeah, it's a non-free service, but I will happily take advantage of it in order to make the information more free, and things like that. I use both free and non-free things, but I love the single-minded focus that a lot of people have on freedom and making sure that other people enjoy these rights. For example, in the Emacs community, a surprising number refuse to use JavaScript because a lot of JavaScript is non-free software. I want to make sure that my website still makes sense without JavaScript. EmacsConf, there are ways to participate even participate even without JavaScript. You can use MPV to watch the stream. It's all free software. You can use IRC to chat. All that stuff is very important to people, and that's great. I love the fact that for a lot of people, they really care about making sure other people can continue to enjoy these freedoms to modify things and to build on it. Every so often someone comes into the Emacs community and they're like, oh yeah, I want to make money making packages here. I'm going to put my package behind a paywall. You've got to send me a donation in order to use it. Then they get smacked down so hard. Usually the way it works is someone will then, you know, take a look at their README and say, okay, that looks vibe-coded. I can do it faster and I'll do it for free. That's the usual response to this stuff. Yeah, here's the thing that you're trying to sell, but it's free.
  Matei: So that never works. I was struck by this. It seems to be so absolutely immune to takeover by proprietary stuff.
  Sacha: I mean, it's a startup hustle mentality in other communities, but in Emacs, it does not fly. Mostly because people are, like, are, like, I know the tools you're using, I can do that better myself. There are people who do get sustained by donations from Emacs community members, but it generally is more of a "I appreciate your work and I will send you this voluntary donation" instead of your paywalling your stuff behind this thing, which feels very much against the ethos of the Emacs community. It's been interesting to see the AI hustle "software as a service or product type" thing try to infiltrate the Emacs community, and they are having none of it.
  Matei: Interesting. Why do you think it's so resilient to that?
  Sacha: Because we've had such a long tradition of sharing things for free, building on top of things that people have freely shared: not just like free as in beer, but free as in you've got the source code, you've got all the rights to do whatever you want with it, including for free. That's baked into the community. Any time someone comes in and tries to say, oh yeah, I've got this commercial packaging of Emacs, it's all rights reserved, people are like, yeah, there's probably a GPL violation right there, so let's go.
  Matei: Cool.
  How do you explain your passion for Emacs to non-Emacs users?
  Matei: How do you explain your passion for Emacs to non-Emacs users?
  Sacha: I don't usually. I love the fact that I can tinker with it, right? If it clicks for people, it clicks. But if it doesn't click for people and they don't necessarily want or need that, then it's okay for them to use something else. I love the fact that people are using or even shifting to other editors. For example, we've had a couple of people announce that they're leaving Emacs recently because vibe coding has made it possible for them to build native applications and they don't have to build it on top of Emacs anymore. They can finally get their Vim config set up the way that they wanted to because the LLM can generate that stuff for them. Whereas in Emacs, it would have been a lot easier to write it themselves, but now they can do it with VS Code or whatever. It's great because the more people are experimenting with interesting ideas, even outside Emacs, the more we get to steal those ideas and then bring them back. You see a lot of this sometimes. You see people re-implementing cool ideas from other editors or other tools. To me, it's totally okay if other people use something else, especially if they tell me the cool stuff that they think only that editor can do. Because I'm like, that sounds like an interesting feature. Do tell me more. There was an interesting talk by Jeremy Friesen in either last EmacsConf or the one before that, about mentoring and how he's no longer trying to push people to use Emacs. He wants to share the general workflow practices he's using. If he's pair programming
  Sacha: with someone, he might say, how do you jump to a specific function definition? They might show him something, or they might realize that's a thing. I can go look in my editor how to do that. He might show, this is how I do it. That's the general idea. Sometimes when people start talking workflow, then talking workflow, then talking workflow, then people who are not using Emacs will go, "That looks really cool. How do I do that?" Then that?" Then you send them down the path of: get it installed, go through the tutorial, that sort of stuff. But it always helps to have that specific reason, the thing that they want to be able to do. For me, for example, I love the way that Org Mode lets me have my notes and the code and the links. It's all one big thing. I don't have to think about, oh, okay, I have to do everything in Python because that's what Jupyter does. I can do some of it in Emacs Lisp, and I can do some of it in shell scripts, and I can do some of it in JavaScript or Python. It's like all this big mess Org Babel kind of thing. Yeah, because your brain might not be in tune with all those different languages, but it works for me. If other people see that and they say, I want to do that too, then that's when you help them get into Emacs. But aside from that, I don't talk to people in elevators and say, have you heard the good news?
  Matei: I was wondering even more broadly than kind of people who are already coding with a different editor. To tell you a story... My cousin is also an anthropologist. He's an anthropologist in France. I've known for years that he was into Linux and free software and stuff. When I got into Emacs, he said, you know I've been doing Emacs for 10 years. I was like, what? How? What? And he'd never told me. I realize now, having been doing Emacs for four years, I can't talk to my colleagues and friends about it because they look over my shoulder and it's like, what are you doing? This looks like it's from the 1980s. Even trying to explain to people what Emacs is... I don't mean coders, I just mean people. My cousin said, yeah, I talk to people about free software all the time. I've never talked to anyone about Emacs. It's just so weird.
  Sacha: I think that's why the community is so important, right? I aggregate a lot of blogs on Planet Emacslife so people can bump into each other. There are a lot of meetups, some of which we host on BigBlueButton... There are meetups, by the way. If you check under Emacs News, there's actually a very active London meetup.
  Matei: I haven't yet.
  To what extent do people meet in person with Emacs?
  Matei: To what extent do people meet in person with Emacs?
  Sacha: Apparently, a lot of people meet in person whenever they're lucky enough to get a sense that there are actually other people in their general geographic location who are interested in this. But there are also a lot of people who meet online. Org Meetup has a meetup every month that has about 20 people in it.
  Sacha: Emacs Berlin has a meetup that's hybrid, and so it's both in person and online. There's Emacs Asia Pacific. There's a whole list of meetups in Emacs News, which is that newsletter that I do every week. I list upcoming events, and there's also a link there to the calendar as well as to the user groups page which lists by region. There are a lot of people getting together about Emacs because a lot of times, you learn about Emacs by looking over someone's shoulder, physical or virtual, right? This is how you learn about things that you would not have even thought of asking an AI about. They're doing a demonstration or they're doing a video, and you're like, what is that thing that you just did? They had no plans to talk about it because it's just something they take for granted. It's a keyword shortcut or a command. It's just part of the workflow. They don't think about it anymore. Or it's even as simple as "What's that theme? What's that font?" Because people can see it, can see somebody doing stuff with Emacs, they get inspired to learn more and to adopt that into their workflow. That is one of the things that I love about how people learn Emacs. It's very convivial, right?
  Matei: Yeah.
  Learning in public
  Matei: You said the phrase earlier: learning in public. In one sense, that sounds scary. Learning in public, making mistakes in public and stuff. You said it as a really good thing. Tell me more about learning in public.
  Sacha: My favorite kinds of blog posts is
  Sacha: when I'm proud of myself for figuring out something clever. Like, okay, here's this function function to do this thing. I had to figure it out. It was hard. It took like a day or two to do it. Then someone comes by in the comments and says, oh yeah, that's built in.
  Matei: Yeah, I've been there.
  Sacha: "You just change this variable." It happens so often. The reason is because Emacs is so big, right? There are variables and functions that I would not think of coming across. Maybe I'm not using the right words to search for them, or whatever. If you add to that the entire package ecosystem and as well as the things that are not people's packaged code, snippets in people's config and whatnot... Chances are someone has come across the same problem that I'm thinking about and has come up with a more elegant solution for it. If I'm not using the same words, I might not find it. One of the things that I like about large language models is that even if I use my words, sometimes it will suggest something that does that translation, right? It's an approximate search. But even if I don't have that, if I'm writing about something, then I have that opportunity for somebody to say, oh yeah, you should check this out. Or several years later, someone might also say, that is exactly what I was trying to do. I'm taking your code. I've built something on top of it to make it even better. For me, writing about what I'm learning
  Sacha: with Emacs is a great way to learn even more from the community. I keep trying to convince people, yes, please, even if you're a beginner, write about what you're learning, because it's a great way to crystallize that knowledge for yourself, become part of the community and part of the conversations, and learn about things that you would not have thought of asking about.
  Matei: Well, I'm following your example. I'm trying to write my config in Org Babel at the moment, partly as a way to say, wait a minute, what is this thing? How does it work? It's so useful. But one thing I was wondering, and it's partly also just a practical question,
  Disclaimers
  Matei: I've never tried to contribute or to post
  Matei: anything on anything, partly because I worry that my stuff is crap.
  Sacha: If you put a disclaimer, that way they know they're reading it for the idea, but not necessarily the Emacs Lisp style. That's fine with me too. There are a lot of people who are like, you know, it's got too many emojis in it, I'm not going to read that. I'm going to focus my time reading something else that's been handcrafted and all that stuff. That's fine too. There's room for all sorts of people and all sorts of approaches to this. Sometimes even just the idea of something is already valuable, that somebody thought of saying, hey, my workflow would be better if it could just do this. If there's a screenshot, even better, right? You can see how it works. Screenshot or video or animated GIF. Because then they can go and write the code that they would have to do anyway. Because of course, they've got their own personalized setup. You know, the code that you write will not mesh perfectly with their particular setup. There's this whole… There's this Lisp curse essay that's sort of related to…
  Matei: I was going to ask you about that.
  Sacha: We've all got our ecosystems of our own code and absorbing something into it is sometimes hard. But if you start with even just the idea that somebody else has written about, whether or not you take their actual code for it or use their code as a building block, that is already useful and interesting. Again, you don't have to be Bozhidar Batsov or Omar Antolin to be able to contribute at that level. Even at the beginner level, you could just be like, I just need to do this thing and it's driving me crazy to do it manually all the time. Then I'm like, you can do that non-manually? Oh yeah, we should do that.
  Matei: Cool. Just to come back to the question about talking to other people about Emacs, do you ever talk to people who are not programmers?
  Do you ever talk to family and friends about Emacs?
  Matei: Do you ever talk to family and friends about Emacs? Do you ever have to explain what this thing is that you're doing or do you just not?
  Sacha: Well, my kiddo is 10, and she's like, can you set me up a kid Emacs? Because she sees me like... Yes! Clearly something of great interest to me. I said, maybe. She does a little bit of vibe coding with Claude as she generates interactive stories. She was trying to track down a syntax error at some point. I was like, can I just install Emacs on your computer so I can do... And she said no. My husband uses Vim.
  Sacha: Although he did get very interested in Org Mode at some point, so he found the appropriate Vim plug-in for it. That was amusing. I don't talk to people about editor choices. I just do the stuff that I do. When I write about it, sometimes people will come across it, again, coming from completely different backgrounds. They'll be like, oh yeah, I also need to edit transcripts. What is this Emacs thing? And I'm like, well, it's a very long road, but it's a lot of fun and it's worth it. If you do want to get into it, here's some ways to get started. I don't know. But you can look at the videos first to see whether it might be something that resonates with you.
  Matei: Yeah. No, I'm the same. I'm very cautious. I've seen that. The learning curve thing is so cool. My kids are like, your computer used to be so pretty when it was a Mac and now it just looks really ugly. I'm like, oh, if you knew. It's so much more beautiful now, but never mind. Cool. We've talked a lot about AI actually already.
  Do you ever use AI in chatbots for anything else?
  Matei: Do you ever use AI in chatbots for anything else?
  Sacha: Well, I'm learning French at the moment. In this case, the kind of the regression to the mean that AI does is very useful for me because I need to know, what is the common word choice here? How do I get the grammar to do the thing? I don't really want to spend an hour of a relatively expensive tutor's time picking apart my subject-verb agreement or my nouns agreeing in plurality with the verbs and stuff like that. It's reasonably acceptable to use large language models for language feedback. That makes sense. In terms of coding, I'm not there yet. Quite a few people are very enthusiastic about it. Even in Emacs, some people are like, "I don't write my code anymore. I just vibe the whole thing." I love the way that it gets a lot of people to make things that they would not otherwise have the time or effort or experience to do, but on the other hand also, it hallucinates a lot of things. It gets me excited: oh there's a variable or function specifically for this? No! It doesn't exist. I can make it exist, so it's a little less frustrating for me, because I can say, you know, that does make sense. I can write that. I can fill in the blanks for it. But 9 times out of 10, I'll be like, no, no, go back and do the proper search. One out of 10 times, it'll tell me, oh yeah, there is this function and it will exist, exist, then I'm like, okay, great, I want to use that, because I wouldn't have otherwise come across it. But I cannot use it to generate a lot of code because I get this urge to just rewrite things to fit the way I want. I just use it like… it suggests ideas. It acts kind of like a search engine that gets things wrong most of the time. I'll just take the interesting parts of that and do it myself. Aside from that, I haven't really dug into it to the extent that other people have. I am happy to take a step back and see how this all shakes out because with the shake-up in pricing and all the externalized costs that are slowly being factored in, I'm not going to build a house of cards on it.
  Matei: Yeah, that's very wise, I think. How do you feel about the fact that these models have been trained on all these free conversations? They just suck up all this stuff that people have been doing for 40 years. Is that a problem in and of itself?
  Sacha: It's interesting in the particular case of Emacs. As I mentioned, the vast majority of Emacs Lisp is released under either the GPL or the MIT license or even public domain because people in Emacs really care about sharing stuff and they want other people to do it. It's not like, oh, we've got this proprietary code and it's been stolen away from us, it's us, it's not available for other people. The fact that we're treating AI-generated code as non-copyrightable, it's okay that it's sort of out there. It would be nice to be able to say, hey, this stuff is GPL, so if you're going to build on it, please share it under the same licenses. But in terms of the way that many people use it for personal configuration and learning, I'm okay with that. I know that other people in the community have stronger stances, and that's also okay. Because there's no attribution, there's no link back to the person. The licensing doesn't require [lots of] attribution. You don't have to say, oh yeah, this config was inspired by these people and at these links. You don't have to do that, but it would be nice to be able to follow those links back to the people. That would be nice. The ability for more people to learn from this stuff is good. If we can encourage them to share what they're figuring out with other people, that's also good.
  Matei: So is the problem less about kind of taking intellectual property and more about
  Not breaking connections to people
  Matei: breaking connections to people or like breaking these traceable connections to other people in the community?
  Sacha: That's the part that I'm interested in and care about, because I feel the community experience of Emacs is very interesting. All the other stuff, there are people who are far smarter than me and have focused on... This is above my pay grade, right? Actually working out intellectual property, what that means. A lot of people think about copyright and copyleft and that stuff. I will leave that to them to sort all of the ethics after that one. I just care about making sure people can feel like they're learning, feel like they're welcome, and can find the ways forward both with assistance of large language models if they want to, but also connecting with real people who they can learn from too.
  Matei: Yeah, super. I think that's sort of the questions I had, really. I'm sure I'm going to have a million other questions. I might email you back about this. Did you have any questions for me?
  Education and ethics and eureka
  Sacha: I love now knowing that you were writing your manifesto with that experience of being an Emacs user in mind, because the way that the education and ethics and eureka was like, that actually lines up precisely with the Emacs community and what it's like and what we care about. I would love to explore this in future conversations and see how we can help people navigate this time. There's a lot of froth about AI, and the business world is losing their heads over this collectively. The programmers in industry either find it useful but also, in general, seem to have a fairly worse experience. This is not where we should be using this. This is not how this is supposed to be turning out. It should not be leading to more unhappiness, but it is. It would be interesting to sort out both in the society level, but also in the individual level, as people make their own choices about what to use and how much to use it for, and also the impact, even if they're not making those choices themselves. I think the general sense now, for at least Emacs and Org Mode, is "we're not going to accept LLM-generated contributions because we've got to have a person who can stand behind the code." We so far have been safe from the inundation of generated pull requests that are plaguing other open source projects. It's definitely something to watch out for. But there is some tension. People are proud of their vibe-coded projects, but on the other hand, people are like, well, it takes 5 minutes or 15 minutes to generate this, and because it's not really maintainable, people will lose interest in it after their 15 minutes of fame on Reddit with their nice screenshots and all that. It's not going to keep moving forward.
  Matei: Is that kind of like a… version of the Curse of Lisp written large? Everyone's just going to write their own programs at home and no one's going to be talking to each other anymore.
  Sacha: It is very similar to that. that. It can be a problem. It can be an opportunity. It's not one or the other yet. We're figuring out as a community and as individuals how to navigate this. We have this long history of people not actually being able to adopt to adopt someone else's code off the shelf. It's amazing when someone actually puts together a package that can cut across a large variety of use cases. It takes a lot of work to get there, but things like Magit and Org Mode, how do these things happen? Yeah, it's fantastic. I love the fact that we can look at things
  Sacha: like consult and vertico... The fact that they can work for a lot of people is amazing. It's actually pretty rare in the Emacs community. But for the most part, we are in our little fiefdoms and we have to make an effort to do that kind of connection. Whether or not the other person is using vibe-coded code doesn't matter that much. There's still that barrier. Higher barrier if you're dealing with vibe code because they don't understand it and you don't understand it and the code is hard to read. The ideas can be transmitted over blog posts and videos. But at the same time, the fact that more people like you can use this to start to experience the power of Emacs, the customizability of it, and can then go on to imagine, hey, is this what software could be? Can it be personal? Can it be malleable? Can I say, "No company is going to anticipate this particular need, but I can make it for myself."? I think that's really worth it. If the tools will help us get there, and if we can find our own balance of ethics that are okay with this... Some people might say, no, definitely not for me, even if it gives me the power. Some people were like, I just want to get this stuff working. That's cool, too. We get to see how that all works out.
  Matei: It's interesting. I've written this paper for which I gave a talk in Oxford a couple of weeks ago about this, really for anthropologists. It's anthropologists. It's very interesting that a lot of the things we were talking about today, I thought that might be the case on some of these things. It's partly thinking about the way in which AI, ChatGPT, whatever, kind of interferes, becomes like a broker between the community and the individual. So the good side of it is that you're never going to be told to go and read the manual, right? It's always going to say, "Yeah, sure, that's great." But the bad thing is, you're never going to go and read the manual. That's the problem, right? But what I said at the end of it and I don't know whether this resonates at all, but I said now that I'm becoming aware that this is a problem, the paradox that I got into Emacs for the community and yet, in a way, I'm being moved away from the community. Increasingly, now, I will ask not "write this code for me" but "explain to me why this code doesn't work" or "explain to me why my problem could be done differently," and even more than that, not even "explain to me this" but "suggest to me how I could post this on a forum." I'm a bit worried about posting on a forum in case someone turns around and says, that's stupid. Claude or someone can say, if you write it like that, some people might find it interesting. Does that feel like a different kind of use of AI maybe?
  Sacha: It does, and I encourage the more reflective use of it. For example, you might say, instead of generating this code, you might say, can you help me figure out what it is that I actually want to have in my workflow? Can you ask me questions to help me figure out how to do this or how to break it down into smaller tasks? Then that might be a more useful way of doing it. Sometimes people respond better when something is asking them questions. That is possibly an interesting use of AI.
  Matei: Amazing. Sacha, thank you so much for your time.
  Future conversations
  Matei: Having had this conversation, do you think there's matter here for some kind of live stream or something, maybe with other people who want to talk about this stuff?
  Sacha: In fact, if you wanted to take this recording and plop it somewhere public, I am totally fine with that. Learning out loud is how we have these conversations grow, right? The conversation is like this brain dump of ideas, and if we want to start unpacking those ideas and exploring them through all the multifaceted perspectives that we have in the Emacs community, other anthropologists or people who are interested in the philosophy of it, there's people who have so much deep experience in things that I have no idea. I would love for them to be able to say, let's take this facet of this conversation and build on it and explore that one. I am totally okay with both sharing this conversation, if you want to, as well as having other conversations that other people might be able to ripple out from.
  Matei: Fantastic. I mentioned to Protesilaos that we're going to have this chat, and he said, you know, if you want to at some point organize a discussion over this kind of stuff, he'd be very happy to be involved.
  Sacha: I've been experimenting with making myself ask people for help. Prot has coaching sessions. If our schedules can line up, then I can schedule a three-way conversation. It can be live and we can build on the ideas that you might have or follow-up questions that you might have, and then we can see if other people do as well. So that could be good. I'm looking forward to hearing about your insights. I would love to see where this goes. I think the Emacs community is definitely worth studying. I think that there are insights here that you might not otherwise come across in more specialized, more focused... Like, just developers or whatever, or more focused on closed source. There's something interesting about this mix of Emacs and AI and plain text and all that stuff. I would love to see where this goes.
  Matei: Amazing. Thank you very much.
  Sacha: All right. Bye.
  Matei: Bye.
  
  If you want to chat about Emacs and AI, you can e-mail Matei or check out Matei Candea | Anthropology.
  
  View Org source for this post
  
  You can e-mail me at sacha@sachachua.com.
9. 🔗 @binaryninja@infosec.exchange In Sidekick 26.0, Indexes give you a persistent work queue for reverse mastodon
  
  In Sidekick 26.0, Indexes give you a persistent work queue for reverse engineering! Create one from a BNQL query, then keep adding as you find more. Sidekick can also write to indexes during analysis. Later, use the index to filter down, pin what matters, and jump straight to each location. https://docs.sidekick.binary.ninja/guide/indexes.html
10. 🔗 r/LocalLLaMA I trusted random person on this subreddit and bought 3080 20gb made of chinesium rss
  
  | I don't know how long it will last, but it works, and I want 2 more now. submitted by /u/SwimmerJazzlike
  [link] [comments]
  ---|---
11. 🔗 sacha chua :: living an awesome life Emacs Carnival May 2026 wrap-up: "May I recommend..." rss
  [2026-06-01 Mon]: Thanks to everyone who participated! I've included the links below.
  
  It's May and I like puns, so I'm going to suggest "May I recommend…" as our Emacs Carnival theme this month, building on lively conversations about people's favourite packages on lobste.rs, Reddit, and Hacker News. Let's go beyond packages and talk workflows, tips, practices, perspectives… whatever you'd recommend!
  
  It was pretty nice having a wiki page that people could edit without needing to wait for me, so if you write about this topic, feel free to edit the wiki page and add your link. If you run into problems doing that, please e-mail me and I can add the link for you.
  
  People have already started sharing their recommendations:
  - May Emacs Carnival, Carlos Pajuelo
  - May I Recommend EWM, Dilip
  - What we talk about when we talk about recommending Emacs packages, David Dimagid
  - May I recommend… escaping the minibuffer, Alessio Vanni
  - May I recommend… vibemacsing?, by Giampaolo Guiducci
  - May I recommend… to only add items to your init files you understand and document?, by MartinStemplinger
  - May I recommend… Stop messing around and get work done., by Curtis McHale
  - May I recommend declaring bankruptcy from time to time, by Case Duckworth
  - May I recommend eww for Emacs's innovative UI?, by Omar Antolín Camarena
  - May I recommend… understanding Emacs's patterns, by Charlie Holland
  - May I recommend using your thumbs on Meanwhiling
  - May I recommend thinking of Emacs as your Fortress of Solitude, by Martin Sosic
  - Sacha and Prot Talk Emacs: May I Recommend…
  - May I recommend… Treating Emacs as Emacs, by SouthFox
  - May I recommend: lesser known org-modes, by tusharhero
  - May I Recommend: org2blog, journaling & reading hacks, by Wenshan Ren
  - May I recommend… less stretching for your common commands, by Neil M
  (Still got ideas, just a bit late? Let me know and I can add it here as well as to Emacs News!)
  
  View Org source for this post
  
  You can e-mail me at sacha@sachachua.com.
12. 🔗 sacha chua :: living an awesome life 2026-06-01 Emacs news rss
  There were 17 posts in the in the May carnival topic "May I recommend", very cool! Looking for something to write about next? Check out the June theme Underappreciated Emacs Built-ins hosted by Ross A. Baker.
  - Help wanted:
    
    elfeed getting ready for 4.0 release, bug reports welcome (@minad@mastodon.world)
    
    Help wanted: testing canvas patch on Windows and Mac OS (@divyaranjan@mathstodon.xyz)
  - Upcoming events (iCal file, Org):
    
    Emacs.si (in person): Emacs.si meetup #6 2026 (v #živo) https://dogodki.kompot.si/events/67d716c3-6c04-4530-9c1a-f67aa44d31bc Mon Jun 1 1900 CET
    
    Emacs Paris: S: Emacs workshop in Paris (online) https://emacs-doctor.com/ Thu Jun 4 0830 America/Vancouver - 1030 America/Chicago - 1130 America/Toronto - 1530 Etc/GMT - 1730 Europe/Berlin - 2100 Asia/Kolkata - 2330 Asia/Singapore
    
    EmacsATX: Emacs Social https://www.meetup.com/emacsatx/events/314809959/ Thu Jun 4 1600 America/Vancouver - 1800 America/Chicago - 1900 America/Toronto - 2300 Etc/GMT – Fri Jun 5 0100 Europe/Berlin - 0430 Asia/Kolkata - 0700 Asia/Singapore
    
    M-x Research: TBA https://m-x-research.github.io/ Fri Jun 5 0800 America/Vancouver - 1000 America/Chicago - 1100 America/Toronto - 1500 Etc/GMT - 1700 Europe/Berlin - 2030 Asia/Kolkata - 2300 Asia/Singapore
    
    Emacs Berlin: In-Person-Only Emacs-Berlin Stammtisch https://emacs-berlin.org/ Tue Jun 9 1900 Europe/Berlin
    
    OrgMeetup (virtual) https://orgmode.org/worg/orgmeetup.html Wed Jun 10 0900 America/Vancouver - 1100 America/Chicago - 1200 America/Toronto - 1600 Etc/GMT - 1800 Europe/Berlin - 2130 Asia/Kolkata – Thu Jun 11 0000 Asia/Singapore
    
    Atelier Emacs Montpellier (in person) https://lebib.org/date/atelier-emacs Fri Jun 12 1800 Europe/Paris
  - Emacs configuration:
    
    May I recommend… less stretching for your common commands, by Neil M
    
    Charles Choi: Anju v1.5.0 Update - mouse context menus
    
    Kemal: Brainiac v2.0 released (Codeberg, Reddit)
    
    dotfiles/emacs/.config/emacs/configuration.org at main · hrs/dotfiles · GitHub (@hafner)
  - Emacs Lisp:
    
    Wanna give a shout-out to Exercism.org's Emacs Lisp track (Reddit)
    
    Xah Talk Show Ep787. emacs lisp. add width height to all thumbnails (01:01:25)
  - Appearance:
    
    vim-file-locals: A small package to support some of Vim's modelines in Emacs (Reddit)
    
    Senka07/turboc-emacs-theme · GitHub (Reddit)
  - Navigation:
    
    Tip: bind scroll-up-line and scroll-down-line to shortcuts to make it easy to read when a cat is blocking part of the screen (@lightspill@tailswish.industries)
  - Writing:
    
    Raymond Zeitler: zap-to-char M-z (Irreal)
    
    TAONAW - Emacs and Org Mode: Installing Harper on Kubuntu: The Right Way. Maybe. - grammar check
  - Denote:
    
    Using Denote for Email: A manual workflow | The Art Of Not Asking Why (@jtr@fosstodon.org)
  - Org Mode:
    
    I Replaced Obsidian with Doom Emacs & Org Mode (14:37, Reddit)
    
    Refining Org-mode Deadlines - Wai Hon's Blog (@whhone)
    
    Speeding up org-agenda by keeping org-agenda-files to a minimum
    
    tusharhero: May I recommend: lesser known org-modes: org-num-mode, org-toggle-pretty-entities (@tusharhero@mathstodon.xyz)
    
    May I Recommend: org2blog, journaling & reading hacks, by Wenshan Ren
    
    Import, export, and integration:
    
    Memacs: added module for getting PodcastAddict episods into Org Mode (@publicvoit@graz.social)
    
    tnalpgge/ox-wikidot: org-mode exporter for Wikidot markup - Codeberg.org (@nasunasu@bsd.network)
    
    TAONAW - Emacs and Org Mode: Journelly and OSM for Emacs are good together - OpenStreetMap locations
    
    Notes from #29 bbb:OrgMeetup on Wed, March 11, 19:00 UTC+3 (@yantar92@fosstodon.org)
    
    Org development: etc/ORG-NEWS: Announce about internal changes in org-colview
  - Coding:
    
    Tip about using show-paren-context-when-offscreen (@kickingvegas@sfba.social)
    
    Tip about using magit-git-show-refs (@shoshin@buzz.cicadas.surf)
    
    James Dyer: Stashing a Single File, and Why I Was Too Quick to Blame vc-mode!
    
    Tip about using phpantom_lsp to improve performance of php-mode - @django@kowelenz.social
  - Mail, news, and chat:
    
    The Best Worst Email Client (Irreal)
    
    TIL: Reading Gmail in Emacs with mu4e on macOS | The Cloudlet (Reddit, Irreal)
  - Fun:
    
    oantolin/luggage: A Largely Undesired Gadget: a Generative Art Gallery for Emacs · GitHub (@oantolin@mathstodon.xyz)
    
    Andros Fenollosa: Playing chess online with Emacs
    
    Jugando al ajedrez en red con Emacs | Andros Fenollosa
  - AI:
    
    What’s the least painful Emacs + AI coding agent setup right now?
    
    Built a lightweight, zero-dependency interactive file aggregator (with token estimates) to gather LLM context (Reddit)
    
    Turning agents on their head: LLM help for human authorship (Reddit)
    
    Announcing space-tree: Workspace Management Trees in Emacs (Github, YouTube 27:56, Reddit, HN)
  - Community:
    
    May I recommend… Treating Emacs as Emacs — 狐狸反走矣 (@SouthFox@foxsay.southfox.me)
    
    Sacha Chua: Yay Emacs 32: Sacha and Prot Talk Emacs: May I recommend… (Prot, YouTube 01:01:41)
    
    Emacs Chat 24: Omar Antolin Camarena (YouTube 01:08:11)
    
    Sacha Chua: Karthik's notes on Emacs Chat 24: Omar Antolin Camarena
    
    Emacs with Dr. Howell - FediverseTV (@jameshowell@fediscience.org)
    
    From GNU Emacs to code gouv fr (38:59) - Bastien Guerry
    
    Shibuya.lisp lispmeetup #118 2026-05-28 (01:42:20)
  - Other:
    
    Carnival for June: Ross A. Baker: Underappreciated Emacs built-ins (@ross@rossabaker.com)
    
    real-backup-mode: a package to backup files at each save point, never lose your changes again (Reddit, EmacsWiki)
    
    Marcin Borkowski: Ignoring pdfs when auto-reverting files (Irreal)
    
    Raymond Zeitler: Emacs view- Commands
    
    Emacs bra size calculator - pulusound (@ahihi@anticapitalist.party, HN, lobste.rs, programming.dev)
  - Emacs development:
    
    emacs-devel: Where to find out what happens when a menu is created or handled
    
    Allow optionally disabling the use of TABs for TTY cursor movement
    
    dbus-call-method-asynchronously supports also an ERROR-HANDLER
  - New packages:
    
    elot: Emacs Literate Ontology Tool (ELOT) (MELPA)
    
    f90-ts-mode: Tree-sitter based Fortran 90 mode (MELPA)
    
    lsp-ltex-plus: Grammar and spell checking for LaTeX, Markdown, Org and more (MELPA)
    
    mac-ime: Seamless macOS IME integration without any IME patches (MELPA)
    
    ox-zola: Org export to Zola static site generator (MELPA)
    
    phony: Speech bindings for Elisp (MELPA)
    
    sysml-mode: Major mode for SysML v2 (Systems Modeling Language) (MELPA)
  Links from reddit.com/r/emacs, r/orgmode, r/spacemacs, Mastodon #emacs, Bluesky #emacs, Hacker News, lobste.rs, programming.dev, lemmy.world, lemmy.ml, planet.emacslife.com, YouTube, the Emacs NEWS file, Emacs Calendar, and emacs-devel. Thanks to Andrés Ramírez for emacs-devel links. Do you have an Emacs-related link or announcement? Please e-mail me at sacha@sachachua.com. Thank you!
  
  View Org source for this post
  
  You can e-mail me at sacha@sachachua.com.
13. 🔗 r/LocalLLaMA Entire world: We need more GPUs. Meanwhile, Jensen Huang: rss
  
  | submitted by /u/Nunki08
  [link] [comments]
  ---|---
14. 🔗 r/reverseengineering /r/ReverseEngineering's Weekly Questions Thread rss
  
  To reduce the amount of noise from questions, we have disabled self-posts in favor of a unified questions thread every week. Feel free to ask any question about reverse engineering here. If your question is about how to use a specific tool, or is specific to some particular target, you will have better luck on the Reverse Engineering StackExchange. See also /r/AskReverseEngineering.
  
  submitted by /u/AutoModerator
  [link] [comments]
15. 🔗 r/LocalLLaMA NVIDIA announces Nemotron 3 Ultra rss
  
  | submitted by /u/themixtergames
  [link] [comments]
  ---|---
16. 🔗 doomemacs/doomemacs v2.1.1 release
  
  v2.1.1
17. 🔗 backnotprop/plannotator v0.19.26 release
  Follow @plannotator on X for updates
  
  Missed recent releases? Release | Highlights
  ---|---
  v0.19.25 | Amp plugin production fixes, Mermaid rendering fix, Settings AI-tip flicker fix
  v0.19.24 | Amp integration, configurable data directory, Auto Mode permission option, Pi plan approval fix
  v0.19.23 | Droid integration, Windows Pi AI fix, quieter update indicator
  v0.19.22 | Safari copy fix in plan viewer, CLAUDE_CONFIG_DIR support for session logs
  v0.19.21 | Ask AI in plan review and annotate mode, shared AI runtime, origin-aware provider defaults
  v0.19.20 | Interactive goal setup UI, OpenCode submit_plan fixes, browser no-op sentinel handling for Claude agents
  v0.19.18 | Edit-based submit_plan for OpenCode, Pi namespace migration, Codex annotate-last fix, OpenCode commands dir fix
  v0.19.17 | Reworked goal setup skill (interview-driven flow), CLI --version flag
  v0.19.16 | Code navigation with peek view (Cmd/Ctrl+click tokens in diffs)
  v0.19.15 | Commit-based diff base, jj evolution diffs, GitLab reliability fixes, OpenCode command intercept fix
  v0.19.14 | Visual explainer skill update, PFM code-file hover previews, Graphviz, diff tab size and line bg intensity, hooks settings tab
  
  What's New in v0.19.26
  
  v0.19.26 is a patch release with six changes. Five are bug fixes carried forward from v0.19.25 (Amp plugin production fixes, Mermaid rendering, Settings flicker), and one improves the update notification UX. Two external contributors, one first-timer.
  
  Update Notification Improvements
  
  The previous update indicator was a small red dot on the Options button that was easy to miss. This release adds three layers of visibility. A toast notification appears briefly after the page loads, directing users to the Options menu. The "Options" label in the toolbar now shimmers when an update is available, using the same animated gradient effect shown inside the dropdown. The "Copy update command" button inside the menu is now a filled primary-color button instead of an understated text link.
  
  The toast auto-dismisses after four seconds and only fires once per session. Opening the Options menu still clears the dot and shimmer as before. Both the plan review and code review apps received the same treatment.
  
  Amp Plugin Production Fixes
  
  The Amp integration shipped in v0.19.24 worked in development but failed in production when installed globally. Three issues surfaced once users installed the plugin to ~/.config/amp/plugins/:
  
  The plugin resolved the plannotator binary via PATH lookup, which in Amp's Bun-shaped runtime could resolve to the wrong executable. It now checks the standard installer paths (~/.local/bin/plannotator on Linux/macOS, %LOCALAPPDATA%\plannotator on Windows) before falling back to PATH. A PLANNOTATOR_BIN environment variable is also available for custom installs.
  
  Amp's ctx.$ helper reported the plugin directory rather than the active workspace, so Plannotator commands ran from the wrong working directory. The plugin now reads Amp's CLI log to resolve the real workspace root.
  
  Amp sets BUN_BE_BUN=1 in the plugin environment. The standalone Plannotator binary inherited this variable and behaved like bun instead of executing its own commands, failing with Script not found "annotate". The plugin now strips this variable before spawning the binary.
  - #810, #811, #812
  Mermaid Diagram Rendering Fix
  
  Mermaid diagrams had several visual regressions: blocks rendered at incorrect sizes, zoom level reset on every parent re-render, and the pinpoint drag handle attached to the wrong target. The root cause was that the parent Viewer component re-injected the rendered SVG via dangerouslySetInnerHTML four to five times during mount and again on every re-render, wiping any imperative DOM changes the Mermaid component had applied after render (sizing attributes, viewBox adjustments, zoom state).
  
  The fix has two parts. First, the component is wrapped in React.memo with a custom comparator that only re-renders when the diagram content changes, blocking parent-triggered re-renders entirely. Second, the sizing attributes (max-width, preserveAspectRatio, height) are now baked directly into the SVG markup string before it enters React state, so even when a legitimate re- render does inject the HTML, the attributes survive. The SVG normalization logic was extracted into a separate dependency-free module (mermaidSvg.ts) to keep it unit-testable without pulling in the browser-only mermaid library.
  - #819, contributed by @HyunmoAhn
  Settings AI-Tip Input Flicker Fix
  
  The lightbulb button in Settings that opens the AI instruction tip editor caused intense flickering on open. The slide-in animation used a max-height: 0 → 60px keyframe, which is a layout property. Inside the scroll viewport, this triggered a layout feedback loop: the browser recalculated layout, which restarted the animation, which triggered another layout, roughly 40 times per second. The fix switches the keyframe to opacity and transform (translateY), which are compositor-only properties that don't participate in layout.
  - #830 closing #829, contributed by @j-token
  Install / Update
  
  macOS / Linux:
```
curl -fsSL https://plannotator.ai/install.sh | bash
```
  Windows:
```
irm https://plannotator.ai/install.ps1 | iex
```
  Claude Code Plugin: Run /plugin in Claude Code, find plannotator , and click "Update now".
  
  OpenCode: Clear cache and restart:
```
rm -rf ~/.bun/install/cache/@plannotator
```
  Then in opencode.json:
```
{
  "plugin": ["@plannotator/opencode@latest"]
}
```
  Pi: Install or update the extension:
```
pi install npm:@plannotator/pi-extension
```
  Droid: Install via the plugin marketplace:
```
droid plugin marketplace add backnotprop/plannotator
droid plugin install plannotator@plannotator
```
  Amp: Install the CLI first, then copy the plugin:
```
mkdir -p ~/.config/amp/plugins
curl -fsSL https://raw.githubusercontent.com/backnotprop/plannotator/main/apps/amp-plugin/plannotator.ts \
  -o ~/.config/amp/plugins/plannotator.ts
```
  What's Changed
  - fix: Amp plugin binary resolution by @backnotprop in #810
  - fix: Amp plugin workspace cwd by @backnotprop in #811
  - fix: Amp plugin Bun env leak by @backnotprop in #812
  - fix: Mermaid block sizing, zoom retention, and pinpoint drag by @HyunmoAhn in #819
  - fix: flickering AI-tip input in label settings by @j-token in #830
  - feat: improve update notification with toast, shimmer, and prominent button by @backnotprop
  New Contributors
  - @HyunmoAhn made their first contribution in #819
  Contributors
  
  @HyunmoAhn diagnosed and fixed the Mermaid rendering regressions, tracing the root cause to repeated dangerouslySetInnerHTML injections from the parent component. The PR included a full test suite for the extracted SVG normalization logic. @j-token returned with a fix for the Settings AI-tip flicker, identifying the max-height animation as the source of the layout feedback loop. @jj-valentine filed #829 with a clear reproduction path and a preliminary code-level diagnosis that pointed directly at the animation keyframes.
  
  Full Changelog : v0.19.25...v0.19.26
18. 🔗 backnotprop/plannotator v0.19.25 release
  Follow @plannotator on X for updates
  
  Missed recent releases? Release | Highlights
  ---|---
  v0.19.24 | Amp integration, configurable data directory, Auto Mode permission option, Pi plan approval fix
  v0.19.23 | Droid integration, Windows Pi AI fix, quieter update indicator
  v0.19.22 | Safari copy fix in plan viewer, CLAUDE_CONFIG_DIR support for session logs
  v0.19.21 | Ask AI in plan review and annotate mode, shared AI runtime, origin-aware provider defaults
  v0.19.20 | Interactive goal setup UI, OpenCode submit_plan fixes, browser no-op sentinel handling for Claude agents
  v0.19.18 | Edit-based submit_plan for OpenCode, Pi namespace migration, Codex annotate-last fix, OpenCode commands dir fix
  v0.19.17 | Reworked goal setup skill (interview-driven flow), CLI --version flag
  v0.19.16 | Code navigation with peek view (Cmd/Ctrl+click tokens in diffs)
  v0.19.15 | Commit-based diff base, jj evolution diffs, GitLab reliability fixes, OpenCode command intercept fix
  v0.19.14 | Visual explainer skill update, PFM code-file hover previews, Graphviz, diff tab size and line bg intensity, hooks settings tab
  v0.19.11 | Jujutsu (jj) VCS backend, slimmer hunk separators, collapse viewed files, multi-line gutter selection fix
  
  What's New in v0.19.25
  
  v0.19.25 is a patch release with five bug fixes. Three address production issues with the Amp plugin introduced in v0.19.24, one fixes Mermaid diagram rendering, and one fixes a UI flicker in Settings. Two PRs are from external contributors, including one first-timer.
  
  Amp Plugin Production Fixes
  
  The Amp integration shipped in v0.19.24 worked in development but failed in production when installed globally. Three issues surfaced once users installed the plugin to ~/.config/amp/plugins/:
  
  The plugin resolved the plannotator binary via PATH lookup, which in Amp's Bun-shaped runtime could resolve to the wrong executable. It now checks the standard installer paths (~/.local/bin/plannotator on Linux/macOS, %LOCALAPPDATA%\plannotator on Windows) before falling back to PATH. A PLANNOTATOR_BIN environment variable is also available for custom installs.
  
  Amp's ctx.$ helper reported the plugin directory rather than the active workspace, so Plannotator commands ran from the wrong working directory. The plugin now reads Amp's CLI log to resolve the real workspace root.
  
  Amp sets BUN_BE_BUN=1 in the plugin environment. The standalone Plannotator binary inherited this variable and behaved like bun instead of executing its own commands, failing with Script not found "annotate". The plugin now strips this variable before spawning the binary.
  - #810, #811, #812
  Mermaid Diagram Rendering Fix
  
  Mermaid diagrams had several visual regressions: blocks rendered at incorrect sizes, zoom level reset on every parent re-render, and the pinpoint drag handle attached to the wrong target. The root cause was that the parent Viewer component re-injected the rendered SVG via dangerouslySetInnerHTML four to five times during mount and again on every re-render, wiping any imperative DOM changes the Mermaid component had applied after render (sizing attributes, viewBox adjustments, zoom state).
  
  The fix has two parts. First, the component is wrapped in React.memo with a custom comparator that only re-renders when the diagram content changes, blocking parent-triggered re-renders entirely. Second, the sizing attributes (max-width, preserveAspectRatio, height) are now baked directly into the SVG markup string before it enters React state, so even when a legitimate re- render does inject the HTML, the attributes survive. The SVG normalization logic was extracted into a separate dependency-free module (mermaidSvg.ts) to keep it unit-testable without pulling in the browser-only mermaid library.
  - #819, contributed by @HyunmoAhn
  Settings AI-Tip Input Flicker Fix
  
  The lightbulb button in Settings that opens the AI instruction tip editor caused intense flickering on open. The slide-in animation used a max-height: 0 → 60px keyframe, which is a layout property. Inside the scroll viewport, this triggered a layout feedback loop: the browser recalculated layout, which restarted the animation, which triggered another layout, roughly 40 times per second. The fix switches the keyframe to opacity and transform (translateY), which are compositor-only properties that don't participate in layout.
  - #830 closing #829, contributed by @j-token
  Install / Update
  
  macOS / Linux:
```
curl -fsSL https://plannotator.ai/install.sh | bash
```
  Windows:
```
irm https://plannotator.ai/install.ps1 | iex
```
  Claude Code Plugin: Run /plugin in Claude Code, find plannotator , and click "Update now".
  
  OpenCode: Clear cache and restart:
```
rm -rf ~/.bun/install/cache/@plannotator
```
  Then in opencode.json:
```
{
  "plugin": ["@plannotator/opencode@latest"]
}
```
  Pi: Install or update the extension:
```
pi install npm:@plannotator/pi-extension
```
  Droid: Install via the plugin marketplace:
```
droid plugin marketplace add backnotprop/plannotator
droid plugin install plannotator@plannotator
```
  Amp: Install the CLI first, then copy the plugin:
```
mkdir -p ~/.config/amp/plugins
curl -fsSL https://raw.githubusercontent.com/backnotprop/plannotator/main/apps/amp-plugin/plannotator.ts \
  -o ~/.config/amp/plugins/plannotator.ts
```
  What's Changed
  - fix: Amp plugin binary resolution by @backnotprop in #810
  - fix: Amp plugin workspace cwd by @backnotprop in #811
  - fix: Amp plugin Bun env leak by @backnotprop in #812
  - fix: Mermaid block sizing, zoom retention, and pinpoint drag by @HyunmoAhn in #819
  - fix: flickering AI-tip input in label settings by @j-token in #830
  New Contributors
  - @HyunmoAhn made their first contribution in #819
  Contributors
  
  @HyunmoAhn diagnosed and fixed the Mermaid rendering regressions, tracing the root cause to repeated dangerouslySetInnerHTML injections from the parent component. The PR included a full test suite for the extracted SVG normalization logic. @j-token returned with a fix for the Settings AI-tip flicker, identifying the max-height animation as the source of the layout feedback loop. @jj-valentine filed #829 with a clear reproduction path and a preliminary code-level diagnosis that pointed directly at the animation keyframes.
  
  Full Changelog : v0.19.24...v0.19.25
19. 🔗 HexRaysSA/plugin-repository commits sync repo: +2 releases rss
```
sync repo: +2 releases

## New releases
- [haruspex](https://github.com/0xdea/haruspex): 0.9.2
- [rhabdomancer](https://github.com/0xdea/rhabdomancer): 0.9.2
```
20. 🔗 r/LocalLLaMA MiniMax M3 - Coding & Agentic Frontier, 1M Context, Multimodal rss
  
  | submitted by /u/dryadofelysium
  [link] [comments]
  ---|---
21. 🔗 jank blog Tracing rays with jank rss
  
  I've continued my optimization work through May and today I'll be reporting the status of the next benchmark: a little Clojure ray tracer. Before jumping into the details, I want to say thank you to my Github sponsors and to Clojurists Together for sponsoring me this whole year. Thank you!