🏡

July 15, 2026
1. 🔗 modem-dev/hunk v0.17.1 release
  What's Changed
  - Prevent Windows end-of-diff scrolling crashes and Apple Silicon Yoga warning spam by upgrading OpenTUI to 0.4.3 by @benvinegar in #538
  - Reduce retained memory in large reviews by lazily materializing cached geometry row plans by @matthew-hre in #521
  - Fix global config discovery on Windows when HOME is unavailable by @benvinegar in #533
  Full Changelog : v0.17.0...v0.17.1
2. 🔗 jesseduffield/lazygit v0.63.1 release
  Fixes for a few regressions introduced in the v0.63.0 release.
  
  What's Changed
  
  Fixes 🔧
  - Improve index.lock retry mechanism by @stefanhaller in #5788
  - Fix userEvents panic by @stefanhaller in #5793
  - Fix a deadlock on Windows when switching between longer diffs by @stefanhaller in #5815
  Maintenance ⚙️
  - Allow releasing from a branch other than master by @stefanhaller in #5819
  Full Changelog : v0.63.0...v0.63.1
3. 🔗 pgarba/ida-llm-explainer LLM Explainer v1.7.0 release
  Features
  - Packed-string-table recovery — spots a helper that slices fixed-length substrings out of one merged string blob (a common obfuscation). The model flags it with SUGGESTED_STRING_EXTRACTOR: <fn> ptr=<n> len=<m>; the plugin then reads the constant pointer/length at every call site, defines each carved string literal with a repeatable comment, and invalidates the callers' Hex-Rays cache so the pseudocode re-renders the shortened strings (get_partial_string(dst, blob, 6) → "REFLEX").
  - Caller-fetch (REQUEST_CALLERS) — the model can pull in a few of the target's callers to read the concrete arguments passed at real call sites, sharpening inferred parameter types. New Max callers shown per request setting (default 3).
  Fixes
  - Prune orphaned saved user-lvar entries — silences the Hex-Rays variable defea=... could not be found warnings — conservatively, dropping an entry only when neither its defea nor a concrete storage location survives, so live renames (e.g. a BYREF stack array after a prototype change) are never lost.
  - Collision-avoidance renames now try a trailing underscore (req_ctx → req_ctx_) before numeric suffixes.
  - A SUGGESTED_CALLEE_NAME that proposes the name a callee already has is now skipped silently instead of logging a spurious "ignored" warning.
  - Robust signature application: strips <old> -> <new> arrow forms, falls back to parse_decl + apply_tinfo, and logs the real reason on failure.
  - No-progress guard on the on-demand fetch loop: if a round surfaces no new code or callers, the model is forced to finalize, preventing a request loop.
  - Prompt: stronger argument-typing rule (address arithmetic / string-literal call args imply a pointer type, never a bare integer).
4. 🔗 smol-machines/smolvm smolvm v1.6.2 release
  
  Full Changelog : v1.6.1...v1.6.2
5. 🔗 smol-machines/smolvm smolvm v1.6.1 release
  What's Changed
  - Bump the Nix flake to smolvm 1.6.0 by @BinSquare in #625
  - Fix the pacman repo build so it packages both architectures by @BinSquare in #626
  - Make VM boot failures diagnosable instead of opaque by @BinSquare in #627
  - docs: recommend the unix-socket docker endpoint; document the TCP alternative and its caveats by @BinSquare in #621
  - Add cuda to VmResources for CLI/SDK CUDA-over-vsock by @BinSquare in #628
  - CUDA fork independent serving: copy-on-fork isolation, graph mode, network transport by @BinSquare in #629
  - Detect a stale CUDA guest shim at boot instead of an opaque cuInit failure by @BinSquare in #630
  - feat: expose the docker-socket bridge in the machines HTTP API by @BinSquare in #631
  - Resolve a named config.User to a numeric uid for crun exec (#632) by @BinSquare in #634
  - Warn at launch when CUDA remoting is requested on a host with no usable GPU by @BinSquare in #635
  Full Changelog : v1.6.0...v1.6.1
July 14, 2026
1. 🔗 IDA Plugin Updates IDA Plugin Updates on 2026-07-14 rss
  IDA Plugin Updates on 2026-07-14
  
  New Releases:
  - ida-llm-explainer LLM Explainer v1.6.2
  Activity:
  - augur
    
    41edd0f2: ci: improve
  - capa
    
    30f93787: Merge pull request #3114 from mandiant/dependabot/pip/msgpack-1.2.1
  - ghidra
    
    7462bcec: Merge remote-tracking branch 'origin/patch'
    
    45d95c50: Merge remote-tracking branch
    
    ce37accf: Do not normalize build_exe in pcodetests definitions
    
    d463fbff: Merge remote-tracking branch 'origin/patch'
    
    88566a13: Merge branch 'GP-7065_ghidorahrex_PR-9371_p-mikeg_fix_arm_sev_encoding'
    
    f18269b0: Fix sev.w arm encoding.
    
    237d1a9f: Merge remote-tracking branch 'origin/patch'
    
    87d10fc6: GP-7064: Fixing XmlLoader path traversal
  - haruspex
    
    1edfcb68: ci: improve
  - ida-llm-explainer
    
    21d60a55: Release v1.6.2: batch progress header + hardware note
    
    708885de: README: note the consumer hardware behind the batch screenshot
    
    8c4aafda: README: batch-mode screenshot with a local Qwen model
    
    fd2f8f84: Batch progress label: live done/running/queued counts, avg time and ETA
  - IDAPluginList
    
    a3173079: chore: Auto update IDA plugins (Updated: 19, Cloned: 0, Failed: 0)
  - rhabdomancer
    
    3e09ac3a: ci: add cargo test
  - rikugan
    
    8118c74f: chore(release): bump version to 1.10.4
    
    82c6b418: Merge branch 'feat/docs-review-post-error'
2. 🔗 pgarba/ida-llm-explainer LLM Explainer v1.6.2 release
  - Live batch progress header: done/running/queued counts, average per-function time, and a whole-batch-throughput ETA (reflects multiple llama-server endpoints running in parallel).
  - Fix: BatchProgressDialog crashed on open because _update_progress_label was never defined.
  - README: batch-mode screenshot with a local Qwen model on consumer hardware (Ryzen 9 9950X, 64 GB DDR5-6000, RX 7900 XTX 24 GB).
3. 🔗 r/LocalLLaMA Bonsai 27B: The First 27B-Class Model to Run on a Phone rss
  
  submitted by /u/yogthos
  [link] [comments]
4. 🔗 r/LocalLLaMA Bonsai 27B: 1-bit dense LLM running locally in your browser using custom WebGPU kernels rss
  
  | Very impressive release by the PrismML team. 1-bit quantization shrinks it from 54GB to just 3.8GB (-93%), while retaining 90% of its intelligence. - Collection on Hugging Face: https://huggingface.co/collections/prism-ml/bonsai-27b
  - Demo link: https://huggingface.co/spaces/webml-community/bonsai-webgpu- kernels submitted by /u/xenovatech
  [link] [comments]
  ---|---
5. 🔗 r/LocalLLaMA Prism-ML Bonsai Qwen 3.6 27B rss
  
  | submitted by /u/thoquz
  [link] [comments]
  ---|---
6. 🔗 r/LocalLLaMA Kimi K3 in the next few hours. Deepseek V4 GA later in the week. New Liquid models. New Mistral models sometime this month. And some rumours suggest GLM 5.5 is coming in August. Openweight AI is eating good. rss
  
  | dam bois we eating good this week ngl, The velocity of the open_weight ecosystem right now is hitting a point where proprietary, closed-source APIs are losing their leverage on compute intelligence. When you have DeepSeek V4 dropping native MXFP4 mixtures of experts with massive context capabilities alongside Liquid's non_transformer breakthroughs and impending heavyweights from Mistral and Moonshot, the raw computational cost of intelligence is plummeting to near zero, scary for sam altman, yippee for us But as the base models become insanely capable commodity infrastructure, the talk inside enterprise engineering teams is shifting . The real problem now isn't "how smart is the open-weight model we hosted on our cluster? problem is "how do we stop this raw,autonomous intelligence from introducing big failure modes into our core systems?" The smarter these open_weights get at multi-step reasoning, the more unpredictable their execution paths become when granted full access to data environments. This infrastructure bottleneck is exactly why the elite engineers are separating the raw model weights from the governance layer. Regulated teams are no longer letting agents talk directly to inner databases or orchestration loops; instead, they are forcing all open-weight model traffic through enterprise grade control frameworks like Palantir Foundry or the Lyzr Control Plane. but all in all good week ahead, i wonder if any of these models will ever reach the short lived popularity of deep seek, i still remember how crazy everyone was when they heard about deepseeks training cost submitted by /u/iSyN707
  [link] [comments]
  ---|---
7. 🔗 earendil-works/pi v0.80.7 release
  Breaking Changes
  - Removed the openai-responses compat.sendSessionIdHeader flag from models.json. Session-affinity behavior is now controlled by compat.sessionAffinityFormat ("openai", "openai-nosession", or "openrouter"). Replace sendSessionIdHeader: false with sessionAffinityFormat: "openai-nosession" (#6496 by @petrroll).
  New Features
  - Cache-friendly dynamic tool loading - Extensions can add tools during execution while supported Anthropic and OpenAI Responses models preserve prompt-cache prefixes. See Dynamic Tool Loading.
  - Message copy shortcut - Ctrl+X copies the last assistant message in the transcript or the selected message in /tree, making older and branched messages directly copyable. See Display and Message Queue.
  - Fable 5xhigh and max thinking - Native xhigh and max thinking levels are available across generated provider catalogs. See Model Options.
  Added
  - Added cache-friendly dynamic tool loading for extension tools activated by tool results. Supported Anthropic and OpenAI Responses models load definitions where they become available, preserving the cached prompt prefix. See Dynamic Tool Loading (#6474).
  - Added inherited native xhigh and max thinking levels for Claude Fable 5 across all generated provider catalogs (#6490 by @davidbrai).
  - Added Ctrl+X to copy the last assistant message, or the selected message in /tree.
  - Added inherited toolChoice support for OpenAI and Codex Responses, including required and named tool selection (#6588 by @xl0).
  Fixed
  - Fixed inherited OpenRouter model context windows to use the top provider's actual context length (#6481 by @davidbrai).
  - Fixed inherited OpenRouter OpenAI-compatible session IDs to use the x-session-id header instead of OpenAI-specific session-affinity fields (#6496 by @petrroll).
  - Fixed Ctrl+V to paste clipboard text when the pasteboard does not contain an image.
  - Fixed /login amazon-bedrock to prompt for and save a Bedrock API key instead of only displaying ambient AWS credential setup instructions.
  - Fixed inherited Amazon Bedrock ambient AWS credentials to keep using SigV4 authentication, including for custom model IDs (#6532 by @ribelo).
  - Fixed inherited Cloudflare Workers AI and AI Gateway authentication to use ambient account and gateway IDs when stored credentials contain only an API key (#6292 by @markphelps).
  - Fixed inherited legacy terminal decoding for Alt+symbol key combinations such as Alt+, and Alt+. (#6523 by @ribelo).
  - Fixed the GitHub Copilot mai-code-1-flash-picker model to route through the /responses endpoint (#6544 by @petrroll).
  - Fixed branch summaries to work with providers that use ambient authentication instead of API keys (#6595 by @davidbrai).
  - Fixed inherited Amazon Bedrock errors to report unhandled provider stop reasons instead of only An unknown error occurred (#6598 by @davidbrai).
  - Fixed npm package removal when installed packages have conflicting peer dependencies (#6604 by @davidbrai).
  - Fixed inherited Azure OpenAI Responses reasoning replay when encrypted_content appears only in the terminal response event (#6608 by @davidbrai).
  - Fixed inherited Anthropic-compatible proxies that omit usage from message_delta events (#6611 by @davidbrai).
  - Fixed inherited OpenCode OpenAI Responses models to omit the unsupported session-id header while preserving other cache-affinity data (#6645 by @davidbrai).
  - Fixed system prompt cache invalidation across dates by removing the current date from the default prompt (#6621).
8. 🔗 r/LocalLLaMA 👀A new GLM model incoming rss
  
  | Spoiler from one of the founders of Z.ai who released GLM 5.2 a month ago. Get ready for something new 🥳 submitted by /u/serige
  [link] [comments]
  ---|---
9. 🔗 smol-machines/smolvm smolvm v1.6.0 release
  What's Changed
  - docs(security): clarify workload isolation model by @Kevin-Liu-01 in #606
  - fix(ci): serve the pacman repo from GitHub Pages and auto-publish it on release by @BinSquare in #611
  - Publish official .deb and .rpm repos alongside the pacman repo by @BinSquare in #612
  - Clean up deb/rpm packaging lintian and rpmlint findings by @BinSquare in #613
  - Fix the deb/rpm build broken by a leftover LICENSE.txt copy by @BinSquare in #614
  - Ship smolvm as a Nix flake package, auto-bumped on release by @BinSquare in #615
  - CUDA-over-vsock: fork warm GPU VMs and run vLLM through the remoting by @BinSquare in #616
  - feat: expose the guest Docker daemon socket to the host over vsock by @BinSquare in #618
  - libkrun: vendor the vsock half-close fix (linux-x64 + macos) by @BinSquare in #619
  - fix: honor TCP half-close in the virtio-net relay by @BinSquare in #620
  - chore: re-vendor libkrun at f55362a for the TSI remote-half-close fix by @BinSquare in #622
  - Kubernetes containerd-shim-v2 runtime by @BinSquare in #610
  - Bump the workspace to 1.6.0 for the CUDA remoting, Docker-socket, and Kubernetes shim features by @BinSquare in #623
  New Contributors
  - @Kevin-Liu-01 made their first contribution in #606
  Full Changelog : v1.5.2...v1.6.0
10. 🔗 r/LocalLLaMA I just don't get it. These big tech companies can illegally scrape the entire internet and gatekeep their better models behind higher prices. So it's natural that people look for affordable options, and there will be providers who apparently distill models from them. rss
  
  | The irony? They cry existential threat when they were the ones who made us feel that way first. submitted by /u/Blue-Sea2255
  [link] [comments]
  ---|---
11. 🔗 @HexRaysSA@infosec.exchange 📢 IDA 9.4 is here! mastodon
  
  📢 IDA 9.4 is here!
  Huge thanks to our beta testers for spending the last several weeks refining this release.
  
  • The Apple Dyld Shared Cache workflow has been rebuilt from the ground up.
  • The decompiler now speaks Swift, with proper ABI modelling for self, async context, and error paths.
  • Two new processor modules land — Qualcomm Hexagon and MCore.
  • Navigation gets a major upgrade with Pathfinder and a redesigned Jump Anywhere.
  • The Teams add-on now runs on Git.
  • And idalib, previously Pro-only, now ships with IDA Home.
  
  👉 Read the blog for the full breakdown and/or jump ahead to the release notes, then grab your update in the Download Center.
  https://hex-rays.com/blog/ida-9.4-release-a-new-dyld-shared-cache-swift- analysis-new-teams-add-on-and-more-
12. 🔗 New Music Releases Saliva - Longshot rss
  Saliva - a new release is available:
  - 2026-07-14: Longshot (Single)
  Amazon: Canada | Deutschland | France | United Kingdom | United States
  
  Visit muspy for more information.
July 13, 2026
1. 🔗 IDA Plugin Updates IDA Plugin Updates on 2026-07-13 rss
  IDA Plugin Updates on 2026-07-13
  
  New Releases:
  - christian-doctrine v0.1.0
  - Spectra 1.2.8
  Activity:
  - augur
    
    d524797b: chore: update deps and lint allowlist
  - christian-doctrine
    
    f1f982e3: fix(deploy): auto-restart engine stacks on reboot (restart: unless-st…
    
    8618ff92: feat: companion web+mobile app, engine on VPS, doctrine PDF archive
  - CTF-Tools
    
    a6a81ac5: Add webshell files for remote command execution
  - disrobe
    
    c7571052: flutter aot: recover declared class and method names from a stripped …
    
    3f78fcc1: nspack: derive the per-image e8/e9 marker byte and only rewrite branc…
    
    dd12bd14: py-decompile: recover an except-as-e handler's trailing else/sibling …
    
    7cac6275: update spin to 0.9.9 after 0.9.8 was yanked, keeping cargo-deny green
    
    f7afbac4: refresh the pinned python metric to 96.05 percent (6038 of 6286)
    
    37f98183: mpress: reverse the packer's exact x64 e8/e9 and rip-relative branch …
  - haruspex
    
    ba18a6b1: chore: update deps and lint allowlist
    
    ccf34e82: test: improve doctests that return a Result
  - ida-ins-hinter
    
    3614c115: Initial release of IDA Instruction Hinter
  - ida-llm-explainer
    
    f10d1c80: Batch dialog auto-apply-on-Done; reliable lvar rename/type fixes; v1.6.1
  - ida-sdk
    
    d76bad44: docs: update ida-cmake acknowledgements
  - IFSO-CYBER-FORENSICS-PROJECT
    
    63d44581: new changes
    
    62970198: Cross-platform setup, docs, and clean up
  - rhabdomancer
    
    207cae2d: ci: improve
    
    5938a449: chore: update deps and lint allowlist
  - rikugan
    
    5e91c3f6: fix(loop): scope traceback to execute_python + add integration test f…
    
    910148b5: docs: update CLAUDE.md docs-review gate section for post-error migration
    
    3be1db8f: chore: apply ruff format to 5 files (clean up trailing newlines + min…
    
    4c02ab93: feat(ui): replace docs-gate checkbox with docs_review_mode combobox
    
    ecf001a6: test(loop): strengthen post-error reviewer guard tests
    
    1284eb74: feat(loop): move docs-reviewer from pre-execute to post-error
    
    bb68b2f4: feat(reviewer): update docs-reviewer prompt for post-error role
    
    20fea07b: test(prompts): tighten docs-review-section regression guard
    
    b4df042e: feat(prompts): add IDA API Module Quick Reference to system prompt
    
    3ba4b6a0: refactor(config): replace require_ida_docs_for_complex_scripts with d…
    
    471f7c3b: feat(tools): add traceback_classifier for post-error docs gate
    
    ea383027: docs(plan): docs-review post-error implementation plan
    
    d40f4a9f: docs(spec): docs-review gate post-error hybrid design
    
    b0b6611f: Merge remote-tracking branch 'EliteClassRoom/master'
    
    9c42ba9e: Refactor the code to make it faster to run
    
    ea05a552: chore(release): bump version to 1.10.3
    
    227a0767: chore(deps): sync uv.lock with pyyaml dev dependency
  - Spectra
    
    87bd645f: Remove legacy CLI commands and simplify agent output
    
    b855330f: Stop spinner before approval prompt and clear UI
    
    4707ced1: Improve CLI thinking spinner and line handling
    
    d363b24e: Simplify thinking animation in shell UI
    
    bbba5eb0: Improve markdown table parsing and rendering
    
    859f78de: Update shell_ui.py
    
    12ad1812: Enhance memory clearing in shell REPL
    
    090fc3d4: Add /clear_memory command
    
    c34b88c3: Batch consecutive tool results and add check_tools
    
    57b53707: Add session delete command parsing
    
    e776fb28: Add /history command to view session messages
    
    23ef5a9c: Add loading spinner and tool progress indicators
    
    49d102f4: Add input timeout and attempt limits to CLI
    
    85ec13f2: Add vulnerability analysis skill; v1.3.0 release
2. 🔗 r/LocalLLaMA J-Wash: A novel way to brainwash and customize large language models based on Anthropic's Jacobian-Lens! rss
  
  | submitted by /u/Extraaltodeus
  [link] [comments]
  ---|---
3. 🔗 r/LocalLLaMA This is why we need local models and opensource harnesses rss
  
  | submitted by /u/Comfortable-Rock-498
  [link] [comments]
  ---|---
4. 🔗 Hex-Rays Blog IDA 9.4 Release: A New Dyld Shared Cache, Swift Analysis, New Teams add-on, and more ... rss
  
  After weeks of feedback and refinement from our beta testers, we are excited to introduce IDA 9.4!
  
  Building on 9.3, this release reworks how IDA handles Apple's Dyld Shared Cache, teaches the decompiler to speak Swift, adds two brand-new processor modules, and reshapes everyday navigation with the new Pathfinder widget and a redesigned Xrefs Graph. There is also a change we are especially happy about for hobbyists: idalib, our headless automation library, now ships with IDA Home.
5. 🔗 r/LocalLLaMA I benchmarked 15 "E-Waste" GPUs with Modern Workloads rss
  | I've spent the last year building GPU coolers and a custom benchmarking tool to figure out if decommissioned NVIDIA enterprise GPUs have any use with modern workloads. Cards like the P100 (16GB) are going for around $75 and the V100 (16GB) for under $200. Combined with dirt-cheap X99 Xeon motherboards, they are a massive source of idle VRAM that's hard to ignore for the homelab. People often finger-wag and warn against these due to EOL software and terrible power efficiency. But for a homelab? You can easily work around software limits by compiling older software (like llama.cpp) from source, and to save power, just turn the box off when you aren't doing AI tasks. Over the winter, I used a custom Dockerized benchmarking suite to test a whole box of Tesla GPUs (K80, M10, M40, M60, P40, P100, V100, T40) across LLMs, computer vision, Blender, Whisper, and more. Here is the TL;DR of the results:
  - The V100 is the Sweet Spot : The V100 (16GB) completely surprised me. Its performance hangs right up there with the much more expensive T40.
  - P40 > P100 for LLMs: The community consensus holds true here. If you specifically want to run Large Language Models, with Pascal, use P40.
  - M60 is a Whisper Beast : If you have a ton of audio transcription to do, the M60 is shockingly capable (beating even V100) and can be had for only $50.
  - Scaling is Linear : Stacking cards doesn't hit a wall of diminishing returns within a 4U chassis. More GPUs generally equal linear performance scaling, though if you mix generations, slower cards will bottleneck your faster ones in LLM setups.
  - CPU/Mobo Choice : Faster single-core CPU speeds help slightly for tasks like Whisper and Vision Transformers, but generally, any cheap X99 board and high-lane Xeon will feed these GPUs perfectly fine.
  The complete set of graphs and findings are on my blog. Now that I have the setup and tooling, I'd love to benchmark more workloads, anything missing from my findings you'd like to see next? submitted by /u/eso_logic
  [link] [comments]
  ---|---
6. 🔗 r/LocalLLaMA Apple M7 Ultra Chip Planned With Up to 1.5 TB of Unified Memory rss
  
  | submitted by /u/Mochila-Mochila
  [link] [comments]
  ---|---
7. 🔗 r/LocalLLaMA I got Gemma 4 running directly inside Godot using only GDScript and Vulkan compute shaders rss
  
  | I wanted to see if an LLM could run inside Godot without llama.cpp, Python, a server, or a GDExtension. It works. This Godot 4.7 project runs gemma-4-E2B-it-Q4_K_M.gguf locally. The model calculations run in Vulkan compute shaders, while GDScript handles GGUF loading, tokenization, sampling, the KV cache, and the chat UI. It is only an experiment. It supports this one model and is about 10× slower than llama.cpp with CUDA. Still, I found it interesting that this was possible using only Godot. Code: https://github.com/asallay/godot-llm submitted by /u/toxicdog
  [link] [comments]
  ---|---
8. 🔗 Rust Blog crates.io: development update rss
  Another six months have passed since our last development update, and the crates.io team has been busy. Here's a summary of the most notable changes and improvements made to crates.io since then.
  
  Source Code Viewer Crate pages now have a "Code" tab that lets you browse the contents of published crate versions directly on crates.io. This shows you the exact files that cargo downloads when you add a crate as a dependency, which might differ from the linked repository. This makes it much easier to audit your dependencies, including files that never appear in the repository, like the normalized Cargo.toml files that cargo generates. The viewer comes with a file tree sidebar with search functionality, syntax highlighting, and GitHub-style line selection, where clicking or dragging line numbers produces shareable #L10-L20 URLs. Under the hood, the server now builds a zip file for every published version. Since the .crate files that cargo consumes are gzipped tarballs without random access support, a background job re-packs each of them into a seekable zip archive plus a JSON manifest describing the contained files. Both are served from our static CDN. The frontend then fetches only the manifest and loads each file on demand with an HTTP range request. Because of this architecture, browsing crate sources essentially adds no load on the crates.io API servers. Existing crate versions have been backfilled, so this works for old releases too. The rendering library behind the code viewer is a diff renderer at heart, and that's no accident: a version-to-version diff viewer built on the same infrastructure is currently in the works. This will allow you to review exactly what changed between two published versions, right on crates.io. Stay tuned! Untangling crates.io Accounts from GitHub At the end of May, the crates.io team accepted . Crates.io accounts always
  
  have been tightly coupled to GitHub: signing in means "Log in with GitHub", and your crates.io identity is your GitHub username. The RFC changes that. It introduces usernames that are native to crates.io and independent of linked GitHub accounts, as a prerequisite for eventually supporting login via other identity providers.
  
  The implementation of crates.io usernames has started, but there is still a lot left to do, most visibly the ability to change your crates.io username. After that is complete, there will be future RFCs and implementation for signing in with identity providers other than GitHub. Since all of this touches authentication and account security, we are deliberately taking it slow and rolling these changes out in small, carefully reviewed steps.
  
  Advisories and Suggestions
  
  In our January update we introduced the "Security" tab, which shows security advisories from the RustSec database. We have since taken this integration one step further: crates that RustSec has flagged as unmaintained now show a warning banner directly on their crate pages, linking to the corresponding advisory for details and possible alternatives. Thanks to Dirkjan Ochtman for implementing this feature!
  
  Related to this, some popular crates have been largely absorbed into the Rust standard library over the years, like lazy_static, which has been superseded by std::sync::LazyLock since Rust 1.80. Crate pages of such crates now show a friendly "You might not need this dependency" banner describing the standard library replacement, and superseded crates in dependency lists get a small light bulb icon with a similar hint.
  
  The dataset behind this feature lives in the new rust-lang/std-replacement- data repository, together with a documented inclusion policy: standard library replacements only, every entry must cite the stable std, core, or alloc API and Rust version, and crate maintainers get a notice-and-comment window before an entry is added. New entries can be proposed upstream and can benefit other tools too.
  
  Ferris
  
  The most delightful change of this cycle: the Ferris on our error pages now follows your mouse cursor with its eyes:
  
  Getting a 404 error on crates.io is now slightly less sad.
  
  Svelte Frontend Migration Completed
  
  In our January update, we announced that we were experimenting with porting the crates.io frontend from Ember.js to Svelte. This experiment has concluded successfully: the new frontend reached feature parity, went through a public testing phase in April, became the default at the beginning of May, and the Ember.js app has been removed from our repository.
  
  We designed this change to be invisible for our users, since the new frontend is a 1:1 port of the previous design and functionality. For the team and our contributors, however, it is a big deal: the frontend is now built on a more modern framework, which should make it easier for new contributors to get started. It also allows us to iterate faster, as the source code viewer above demonstrates.
  
  We want to thank the Ember.js team for a framework that served crates.io well for many years, and the Svelte team for making the transition so enjoyable.
  
  Miscellaneous
  
  These were some of the more visible changes to crates.io over the past six months, but a lot has happened "under the hood" as well:
  - Search performance : Relevance-sorted search queries previously ranked every crate matching the query, which could take 1-2 seconds for short or common search terms. Ranking is now bounded to the 1,000 matching crates with the highest recent download counts.
  - Reverse dependencies performance : The reverse dependencies endpoint no longer recomputes the full dependent set on every request. It is now served from a precomputed table kept in sync by database triggers, turning an expensive join into a bounded index scan and greatly reducing the chance of getting a timeout error.
  - New ARCHITECTURE.md : If you've ever wondered how crates.io actually works, our ARCHITECTURE.md document got a complete rewrite. It is now organized around the high-level systems that make up crates.io and how they fit together, and includes walkthroughs of what happens when you run cargo publish, why a typical crate download never touches our API servers, and how download counts are derived from CDN access logs.
  - Definition lists : READMEs now render Markdown definition lists, a widely used Markdown extension. Our markdown renderer comrak already supported them, the extension just wasn't enabled yet. Thanks to @mistaste for this contribution!
  - CDN cache tags : Files uploaded to our static CDN now carry cache-tag metadata, allowing us to invalidate all cached files of a crate or a specific release in a single operation, instead of issuing one invalidation per file URL.
  - Caching improvements : We removed a global Vary: Cookie response header that was preventing our CDNs from caching public API responses and frontend assets effectively. Per-user responses now use Cache-Control: no-store instead, resulting in better cache hit rates at the CDN edge.
  - Accessibility : We have made crates.io friendlier to screen readers: decorative icons are now hidden from the accessibility tree, heading hierarchies have been fixed, and lists are marked up as proper lists. ARIA snapshot tests now ensure that regressions can't slip in unnoticed. We plan to continue to improve crates.io accessibility over the coming months.
  - Git index performance : The background worker's local clone of the git index is now a bare and shallow repository, eliminating roughly 250,000 checked-out files and the full commit history from its disk, improving its performance as we see increased rates of crate publication. The periodic index squashing now goes through the GitHub API instead of generating large git packs locally, which had previously caused out-of-memory failures on the production worker.
  Feedback
  
  We hope you enjoyed this update on the development of crates.io. If you have any feedback or questions, please let us know on Zulip or GitHub. We are always happy to hear from you and are looking forward to your feedback!
9. 🔗 Armin Ronacher The Tower Keeps Rising rss
  I feel that some vibecoded software changes somewhat randomly and unexpectedly. That made me think about Bruegel's "The Tower of Babel" which shows an already quite chaotic depiction of the Tower of Babel. The story is usually told as one about pride and ambition and ultimately why people no longer speak the same language. But it is also a story about the unity that makes technological progress work.
  
  The text begins with a technology upgrade:
  
  And they said one to another, Go to, let us make brick, and burn them thoroughly. And they had brick for stone, and slime had they for morter.
  
  They use it for a civilizational project:
  
  let us build us a city and a tower, whose top may reach unto heaven
  
  But when God assesses the situation the bricks are not what concern him:
  
  the people is one, and they have all one language, […] and now nothing will be restrained from them.1
  
  The source of their power is coordination. They share a language and with that shared language they can combine their work into something no one of them could build alone. God does not take away the bricks or their knowledge of how to make them. He takes away their ability to understand one another, and construction stops.
  
  There is the appealing idea that AI-assisted programming means better tools which lets us build more ambitious software. That is certainly true at the level of the individual and without doubt a developer with an agent will be dramatically more capable of changing a codebase. But large software projects have never been limited only by how quickly an individual can produce code. They are limited by how well people can coordinate their understanding of the system they are changing.
  
  The shared language of a software project is not English or Python but it is the common understanding of what its concepts mean, where the boundaries are, which invariants matter, who owns what, and why the system has the shape it does. This language is rarely written down in one place. It lives partly in documentation and code, but also in code review, conversations, arguments, and the experience of having to explain a change to somebody else.
  
  Before agents, some of this shared understanding was maintained by friction. If I wanted to change your storage layer, I usually had to read your code, ask you questions, and perhaps coordinate with another team whose service depended on it. This was slow, and much of that slowness was waste but not all of it was. Some of it was the process by which your understanding became mine, and by which both of us discovered whether we still agreed about how the system worked. This friction synchronizes people.
  
  Agents remove much of that friction. I can ask an agent to add OAuth, you can ask one to add caching, and somebody else can ask one to rebuild the database from first principles and make the UI pink. Each change can be reasonable in isolation. The code can compile, the tests can pass, and the explanations can be generated on demand. None of us necessarily has to talk to the others, or even acquire the part of the shared model that the change once would have forced us to learn.
  
  As I said many times before: agents do not feel pain, only humans do. Agents now let us act in parts of the system where we would previously have needed other people and in code bases where the people would have revolved.
  
  When I look at some vibecoded scaled-up projects the codebases become Babel not because nobody can communicate, but because nobody needs to. Every developer has a tireless translator that can explain a corner of the tower and make whatever local alteration they ask of it. The changes keep landing, even as the architectural language that would let the humans reason about them together disappears.
  
  But it's not the biblical story. At Babel, the loss of common language stops construction whereas in AI-assisted engineering, construction can continue after shared understanding has already collapsed. The lack of an immediate failure is what makes it curious and a bit disorienting. The tower does not fall, and so we do not notice what was lost. It just keeps rising.
  1. Genesis 11:3-6, KJV.↩
July 12, 2026
1. 🔗 IDA Plugin Updates IDA Plugin Updates on 2026-07-12 rss
  IDA Plugin Updates on 2026-07-12
  
  Activity:
  - ida-llm-explainer
    
    ef604764: SUGGESTED_LABEL: rename Hex-Rays goto labels through the LLM
    
    7c754ac3: Batch picker: sortable name/address/size table + discovery stats
    
    de2e84c6: Batch picker: "Undiscovered Only" filter toggle
    
    598fbc7c: Batch New Name column; global renames, ARM64 indirect-jump recovery; …
2. 🔗 r/LocalLLaMA Apple sues OpenAI alleging trade secret theft, says scheme was 'at every level' rss
  
  | submitted by /u/fallingdowndizzyvr
  [link] [comments]
  ---|---
3. 🔗 smol-machines/smolvm smolvm v1.5.2 release
  What's Changed
  - Preserve sparseness when copying the storage template during pack creation by @BinSquare in #604
  - cuda: llama.cpp + CUDA 13, correctness hardening, cuBLAS BLAS ops, and remote latency/coldstart cuts by @BinSquare in #607
  - Bump the workspace to 1.5.2 for the storage-template sparse-copy fix by @BinSquare in #608
  Full Changelog : v1.5.1...v1.5.2
4. 🔗 r/LocalLLaMA Local Image to 3D (<2gb RAM, <20s, Apple Silicon, iPhone) rss
  
  | TLDR checkout the app here: github.com/ZimengXiong/Modelr My swift-mlx/python mlx port of Hunyuan3D-Paint and Hunyuan3D-Shape is finally complete! It's also available as a standalone image to 3D desktop app, the only of its kind for Apple Silicon. Some quick benchmarks in FP16 on my M4 Max: | run | wall time | peak memory
  ---|---|---
  hy3d shape (small) | 20.9 s | ~5.6 gb
  hy3d shape (large) | 22.3 s | ~7.3 gb
  hy3d paint (rgb) | 231 s | ~38 gb
  hy3d paint (pbr) | 344 s | ~39 gb
  
  This (MLX) makes it possible to run the model on all recent Macs and even iPhones in Q4 or Q8, and more efficiently w/o the overhead of pytorch or even worse, CPU. What you would do with this? I honestly don't really know, maybe simple 3D assets for apps that just rotate around, maybe? But it was a lot of fun seeing it come to life.
  
  I posted a while back about it running on an iPhone, if you want to see that.
  
  The app is very simple, import an image, remove background with SwiftVision, watch as diffusion streams in real time, get a model! From there you can watch texturing happen live as well. I tried to make it very responsive and the most polished version of an app that exists on Mac (well, it's the only one of its kind right now, and this is my fourth attempt of it, starting from November)
  
  If you are interested in integrating fast, low memory Image to 3D inside your Swift app, weights and source are available at github.com/ZimengXiong/Hunyuan3D-Swift
  
  The app, Modelr, is also open source and available for Mac & iOS (extremely limited for iOS): github.com/ZimengXiong/Modelr
  
  submitted by /u/arduinoRPi4
  [link] [comments]
5. 🔗 smol-machines/smolvm smolvm v1.5.1 release
  What's Changed
  - Notify the Homebrew tap to bump its formula on each release by @BinSquare in #588
  - cuda: pipelined async forwarding, CUDA graph capture/replay, and cross-connection ordering — vLLM runs end-to-end with CUDA graphs by @BinSquare in #589
  - Official Arch Linux pacman repository by @BinSquare in #591
  - fix(boot): don't stall 5s when agent-rootfs is read-only by @BinSquare in #592
  - Display init commands progress by @mart-e in #573
  - cuda: cuBLASLt descriptor fast path — eager decode 2x on loopback, in-VM eager beats native by @BinSquare in #593
  - Preserve sparseness when copying disk templates during extraction by @BinSquare in #599
  - release: smolvm 1.5.1 by @BinSquare in #594
  New Contributors
  - @mart-e made their first contribution in #573
  Full Changelog : v1.5.0...v1.5.1
6. 🔗 r/LocalLLaMA China's DeepSeek developing its own AI chip, sources say rss
  
  submitted by /u/TheRealMasonMac
  [link] [comments]
7. 🔗 Kevin Lynagh KiCad helpers and caliper improvements rss
  Hi friends,
  
  This newsletter we're streamlining the process of creating circuit boards and revisiting the DIY electronic calipers project from two years ago.
  
  Kevin's KiCad Helpers
  
  I first started playing around with electronics via Arduino back in 2010, and I designed my first circuit board back in 2015 for my walnut and leather cell phone. Since then, I've made around a dozen PCBs, with a notable spike during the pandemic making weird mechanical keyboards.
  
  Averaging roughly one PCB/year is a maximally frustrating frequency: I have 100's of hours of cumulative experience, but it's sufficiently spread across the forgetting curve that every time I start something the details are only vaguely familiar and I've got to re-orient myself again. It reminds me of filling out my taxes, where I also furiously consult my notes and attempt to interpret them against new versions of the UI where input boxes have been hidden across other forms and new sub-menus.
  
  Anyway, armed with a coding agent, I externalized everything I kept forgetting how to do in a pile of scripts: Kevin's KiCad Helpers.
  
  This is tailored to my needs -- designing PCBs in KiCad 10 to be manufactured by JLCPCB -- but if yours are similar you might find 'em helpful. Even if you don't make PCBs, it might be good inspiration for how to apply LLMs to sand down rough edges of whatever convoluted infrastructure is required for your projects.
  
  A quick tour of the tools:
  
  DXF import
  
  I specify all of my mechanical stuff -- board outlines, mounting hole positions, etc. -- in Autodesk Inventor since it has a constraint solver and allows me to directly reference complex geometry driven by other objects.
  
  KiCad's GUI has a DXF import tool, but it doesn't have a mechanism to replace already imported geometry, which makes it tedious to iterate.
  
  This script:
  - imports geometry from a DXF file into a board layer specified by the filename (panel_Edge.Cuts.dxf imports a group ID'd "panel" to the Edge Cuts layer)
  - deletes any geometry previously imported with that ID
  - polls the file for changes, so you get "live reload"
  I combine this with a similar poll + export-to-file script in my mechanical CAD tool (shown above) to get live syncing to KiCad (shown below):
  
  (Direct video link)
  
  DXFs map into KiCad's origin at top-left of the page outline and the DXF positive Y direction points up, so most of my PCBs end up drawn outside of the page ¯\_(ツ)_/¯.
  
  STEP export
  
  I also need the reverse direction: Import a 3D model of a circuit board and its components back into my mechanical CAD program so I can verify clearances, etc. KiCad has native STEP export, but unfortunately some of the parts have extremely detailed 3D models. My M1 Macbook Air running Windows CAD software in a virtual machine does not do well when every pin of every chip is a separate solid body.
  
  This script generates a STEP export where all parts have been replaced with axis aligned bounding boxes:
  
  Parts database
  
  I design all of my boards to be assembled by JLCPCB, so it's extremely helpful to have a low-latency way to query their parts. This script downloads CDFER's daily JLCPCB parts sqlite database and consolidates everything into a single table with a numeric price column and lots of indexes so that searching is fast:
  
  (Direct video link)
  
  I use DB Browser for SQLite but you can of course use whatever interface you like.
  
  It's also extremely useful to point LLM agents at this database:
  
  My dude, I need an H-bridge that can drive +/- 30 Volts, please query ~/foo/bar/parts.db and give me a table with 5 options for integrated ones showing price / stock / description. Please also make a table showing options for drivers with external transistors. Include links to the datasheets.
  
  JLCPCB (EasyEDA) schematic and footprint import
  
  Shout out again to CDFER for their JLCPCB KiCad Library, which has all of the "basic" jellybean parts and some of the extended ones as well.
  
  For the parts that are not already available in here, I need to import them. Rather than draw them entirely from scratch, I use uPesy's easyeda2kicad.py.
  
  However I don't always want to create an entirely new symbol and footprint if the part actually corresponds to something that's in the KiCad standard library. So my import tool tries to match existing footprints (including 90 degree rotations) and spawns a terminal UI so you can interactively compare potential matches with the EasyEDA footprint:
  
  (Direct video link)
  
  Schematic analysis
  
  The most interesting helper I've created so far is a general schematic analysis framework , which imports the KiCad netlist and schematic instance properties into a DataScript graph database to run various queries/checks.
  
  For example, this lil' function calculates the capacitance (of all the explicit capacitors, anyway) on a given net:
```
(defn net-capacitance
  [db net-name]
  (some->> (d/q '{:find  [?ref ?v]
                  :in    [$ ?net]
                  :where [[?n :net/name ?net]
                          [?n :net/nodes ?node]
                          [?node :node/pin ?pin]
                          [?i :instance/pins ?pin]
                          [?i :instance/ref ?ref]
                          [(clojure.string/starts-with? ?ref "C")]
                          [?i :instance/value ?v]]}
                db net-name)
           (keep (comp parse-capacitance second))
           seq
           (reduce + 0.0)))
```
  This function can then be used to check the total capacitance on, e.g., the power nets, and throw an error if it exceeds, e.g., the maximum 10uF allowed by the USB specification.
```
(defn check-total-capacitance!
  [db]
  (let [rows (->> ["VCC" "VBUS"] ;;TODO: make this configurable
                  (keep (fn [net]
                          (when-let [c (net-capacitance db net)]
                            {:net net :total-uF (format "%.2f" (* c 1e6))}))))]

    (when (seq rows)
      (print "total capacitance:")
      (clojure.pprint/print-table rows)

      (doseq [{:keys [net total-uF]} rows]
        (assert (< (Double/parseDouble total-uF) 10) (str "Net " net " exceeds USB spec 10uF capacitance"))))))
```
  (It's easy to accidentally exceed this limit if you keep incrementally adding ICs and their recommended bypass capacitors.)
  
  Since KiCad allows one to add arbitrary key/value pairs to schematic instances, it's easy to check and print other data as well. For example, I record the i2c address(es) of each chip this way (note i2c and max_mA fields in property inspector on left):
  
  Within the schematic text labels I reference using the KiCad text variable format. (E.g., the above Addr: 0x49 label is defined as Addr: ${U1:i2c}.)
  
  The analysis script throws an error if an address maps to multiple chips:
```
(defn i2c-addresses
  [db]
  (d/q '{:find [?hex-addr (distinct ?ref)]
         :where [[?instance :instance/ref ?ref]
                 [?instance :instance/attributes ?attribute]
                 [?attribute :attribute/name "i2c"]
                 [?attribute :attribute/value ?addrs]
                 [(clojure.core/identity ?addrs) [?addr ...]]
                 [(clojure.core/format "0x%x" ?addr) ?hex-addr]]}
       db))


(defn check-i2c!
  [db]
  (let [refs-by-addr (i2c-addresses db)]
    (when (seq refs-by-addr)
      (print "i2c addresses")
      (clojure.pprint/print-table (sort-by :addr (for [[addr refs] refs-by-addr]
                                                   {:addr addr :refs (clojure.string/join " "  (sort refs))})))

      (doseq [[addr refs] refs-by-addr
              :when (< 1 (count refs))]
        (throw (ex-info (str "Addr " addr " matches multiple refs: " refs)
                        {:addr addr :refs refs})))

      (println ""))))
```
  This also prints out a helpful table of everything on the bus every time I build the project:
```
| :addr | :refs |
|-------+-------|
|  0x20 |    U3 |
|  0x49 |    U1 |
|  0x60 |    U2 |
|  0x61 |    U2 |
|  0x62 |    U2 |
|  0x63 |    U2 |
|  0x64 |    U2 |
|  0x65 |    U2 |
|  0x66 |    U2 |
|  0x67 |    U2 |
|  0x68 |    U2 |
|  0x69 |    U2 |
|  0x6a |    U2 |
|  0x6b |    U2 |
|  0x6c |    U2 |
|  0x6d |    U2 |
|  0x6e |    U2 |
```
  (In this example, U2 is an LED driver and exposes each channel on its own i2c address, so its i2c property is specified as 0x60..0x6F.)
  
  Check/build scripts
  
  Speaking of builds, most of the functionality described above is packaged up as a script, so you just run kkh build in a folder and it'll create an output directory next to every *.kicad_pro it finds in any subfolder. The outputs are named with the date, git revision, and also indicate whether there are unstaged changes in the repository working tree:
```
2026-07-07-73c5c1
├── bom.csv
├── designators.csv
├── netlist.ipc
├── positions.csv
├── receiver-gerbers-2026-07-07-73c5c1.zip
├── receiver.full.step
├── receiver.simplified.step
└── schematics
    ├── receiver-pcb-back.pdf
    ├── receiver-pcb-front.pdf
    └── receiver-sch.pdf
```
  So one command runs DRC, ERC, and custom analysis checks and then builds all of the output files required to place a JLCPCB assembly order.
  
  The build script also exposes the version string as a KiCad variable, so if you add ${KKH_VERSION_DATE} to your PCB silkscreen, the actual version will appear in the output Gerber files.
  
  I hope by making a proper build script I will never again relive the shame of forgetting to run ERC and having a PCB manufactured where I literally forgot to connect some IC pins entirely…
  
  Caliper updates
  
  About two years ago I had my first foray into digital signal processing and made some electronic calipers.
  
  I haven't touched the project since I published that post, but a few folks recently asked me about it, and since I had some spare LLM credits I figured I'd spend five minutes sending off the little dude at the problem.
  
  And I literally mean five minutes -- these are very rough, rambly dictated prompts that I didn't even bother to edit. I'm sharing here to remind everyone (especially myself!) that not everything needs to be A Big New Project and sometimes you can have great success from a quick, low-effort attempt.
  
  I spawned a Claude session in the project repo, dictated the following prompt, and went to brush my teeth:
  
  This is a project that I worked on a while ago and the accuracy that came out was alright but I'm wondering if there's anything I can do to improve the accuracy purely from a computational way rather than making new hardware. Be sure to read the blog post mentioned at the top of the read me to get a background
  
  After I brushed my teeth, it had come up with a few plausible sounding ideas, so I replied with the following and went to sleep:
  
  I'd like you to set this up and come up with a few different ideas. These are pretty good ones and what I want you to do is Wire them up so that I can test them out Individually as a series of experiments with a given protocol and I want you to set everything up as much as possible So I can do it Quickly on my end without having to get in and change the code or anything like that so what you can do is you can make a branch and then Have maybe different entry points or something for each of these different improvements and then Write like an overall program or something like that Which I can just run to test through it and then make it interactive I guess so that I can You know start it up in the hardware Let it sit still for a certain amount of time Move it a fixed amount and back and then You know or some protocol like that and then I'll tell you what I'm done and then we can just run through that program To test out all of the different ideas and potentially combinations of ideas in like a 10 or 15 minute setting and then We'll figure out from that which ones are working most effectively
  
  Again, I'm really not trying that hard here.
  
  I woke up the next morning and spent about 20 minutes setting up the caliper PCBs and then running the programs it generated to collect new measurement data. It tried the following improvement hypotheses (LLM-generated text):
  
  knob | idea it tests
  ---|---
  window size | longer coherent integration (noise ∝ 1/√N), incl. one 50 Hz line period
  mean_sub | remove DC so ADC offset drift can't leak into the phase
  hann | suppress spectral leakage from non-integer-cycle windows
  smoothing | averaging in I/Q (phasor) space instead of phase space; EMA vs block
  hysteresis | the current 0.1 rad dead-band vs smaller vs none
  
  and based on the initial results and a bit more chatting, the agent proposed an improvement that is, of course, completely obvious in hindsight. My initial parameter sweep (two years ago) used a fixed 2kHz spacing. However, the actual signal and sampling timings generated by the microcontroller are driven by integer divisions of a fixed clock frequency -- so most of these sampled timings don't "line up" nicely in terms of an integer number of signal periods.
  
  Thus, there's always a bit of DC bias in the signal, which causes undesired noise.
  
  With this change, the LLM-generated experimental code reports a noise floor of around 50um, which is about 10x better than what I was getting before. I'm currently on holiday away from my lab, but I expect it'll take 30 minutes once I get back to code it up myself and validate.
  
  Anyway, the main takeaways for me are:
  1. Write up your work in blog posts so that both people and LLMs can quickly get context and help you out
  2. There's still plenty of low-hanging fruit out there to pick, and with LLMs it's extremely cheap to just ask
  Misc. stuff
  - Accidental anonymity "Sorry to say it but if you need your work to be polished and beyond reproach, that's a determination and character problem, not a skill problem."
  - High Performance Motor Control From the Ground Up || Field Oriented Control (FOC)
  - How I made a 60fps Eink Monitor, the Modos Flow
  - Quad RF: A Closer Look
  - Bio-Rad Laboratories Helios® Gene Gun sounds like a joke, but it's absolutely real and I desperately want to use it.
  - the flash frozen grocery store
  - I didn't build a Full Body Ultrasound… but I know the people that did
  - Where did all the good sculptors go?
  - I built a fully mechanical calculator
  - AgentsView is a very nice local web UI from my friend Wes McKinney that makes it easy to review transcripts and token usage across Claude Code, Codex, etc. I used it to quote some of my LLM sessions above.
8. 🔗 New Music Releases Phish - 2026-07-12: Ruoff Music Center, Noblesville, IN, USA rss
  Phish - a new release is available:
  - 2026-07-12: 2026-07-12: Ruoff Music Center, Noblesville, IN, USA (Live)
  Amazon: Canada | Deutschland | France | United Kingdom | United States
  
  Visit muspy for more information.