🏡

to read (pdf)

generated: April 03, 2026 at 21:09:47

April 04, 2026
1. 🔗 Rust Blog docs.rs: building fewer targets by default rss
  Building fewer targets by default
  
  On 2026-05-01 , docs.rs will make a breaking change to its build behavior.
  
  Today, if a crate does not define a targets list in its docs.rs metadata, docs.rs builds documentation for a default list of five targets.
  
  Starting on 2026-05-01 , docs.rs will instead build documentation for only the default target unless additional targets are requested explicitly.
  
  This is the next step in a change we first introduced in 2020, when docs.rs added support for opting into fewer build targets. Most crates do not compile different code for different targets, so building fewer targets by default is a better fit for most releases. It also reduces build times and saves resources on docs.rs.
  
  This change only affects:
  1. new releases
  2. rebuilds of old releases
  How is the default target chosen?
  
  If you do not set default-target, docs.rs uses the target of its build servers: x86_64-unknown-linux-gnu.
  
  You can override that by setting default-target in your docs.rs metadata:
```
[package.metadata.docs.rs]
default-target = "x86_64-apple-darwin"
```
  How do I build documentation for additional targets?
  
  If your crate needs documentation to be built for more than the default target, define the full list explicitly in your Cargo.toml:
```
[package.metadata.docs.rs]
targets = [
    "x86_64-unknown-linux-gnu",
    "x86_64-apple-darwin",
    "x86_64-pc-windows-msvc",
    "i686-unknown-linux-gnu",
    "i686-pc-windows-msvc"
]
```
  When targets is set, docs.rs will build documentation for exactly those targets.
  
  docs.rs still supports any target available in the Rust toolchain. Only the default behavior is changing.
April 03, 2026
1. 🔗 cristeigabriela/bb v0.2.1 release
  
  Full Changelog : v0.2.0...v0.2.1
2. 🔗 cristeigabriela/bb v0.2.0 release
  What's Changed
  - feat: functions support by @cristeigabriela in #3
  New Contributors
  - @cristeigabriela made their first contribution in #3
  Full Changelog : v0.1.0-rev1...v0.2.0
3. 🔗 cristeigabriela/bb v0.1.0 -- revision (2) release
  What's Changed
  - feat: functions support by @cristeigabriela in #3
  New Contributors
  - @cristeigabriela made their first contribution in #3
  Full Changelog : v0.1.0-rev1...v0.1.0-rev2
4. 🔗 r/Yorkshire Clearing heavy rain leaves some nice late afternoon sunshine. rss
  
  | Taken near Osmotherley on the western edge of the North Yorkshire Moors. Looking towards Richmond with the Yorkshire Dales in the far distance. submitted by /u/MsJone5
  [link] [comments]
  ---|---
5. 🔗 r/Harrogate Bilton caller rss
  
  submitted by /u/Critical-End-8129
  [link] [comments]
6. 🔗 symgraph/IDAssist Resolve semantic graph targets and repair GraphRAG schema release
  
  No content.
7. 🔗 badlogic/pi-mono v0.65.0 release
  New Features
  - Session runtime API : createAgentSessionRuntime() and AgentSessionRuntime provide a closure-based runtime that recreates cwd-bound services and session config on every session switch. Startup, /new, /resume, /fork, and import all use the same creation path. See docs/sdk.md and examples/sdk/13-session-runtime.ts.
  - Label timestamps in/tree: Toggle timestamps on tree entries with Shift+T, with smart date formatting and timestamp preservation through branching (#2691 by @w-winter)
  - defineTool() helper: Create standalone custom tool definitions with full TypeScript parameter type inference, no manual casts needed (#2746). See docs/extensions.md.
  - Unified diagnostics : Arg parsing, service creation, session option resolution, and resource loading all return structured diagnostics (info/warning/error) instead of logging or exiting. The app layer decides presentation and exit behavior.
  Breaking Changes
  - Removed extension post-transition events session_switch and session_fork. Use session_start with event.reason ("startup" | "reload" | "new" | "resume" | "fork"). For "new", "resume", and "fork", session_start includes previousSessionFile.
  - Removed session-replacement methods from AgentSession. Use AgentSessionRuntime for newSession(), switchSession(), fork(), and importFromJsonl(). Cross-cwd session replacement rebuilds all cwd-bound runtime state and replaces the live AgentSession instance.
  - Removed session_directory from extension and settings APIs.
  - Unknown single-dash CLI flags (e.g. -s) now produce an error instead of being silently ignored.
  Migration: Extensions
  
  Before:
```
pi.on("session_switch", async (event, ctx) => { ... });
pi.on("session_fork", async (_event, ctx) => { ... });
```
  After:
```
pi.on("session_start", async (event, ctx) => {
  // event.reason: "startup" | "reload" | "new" | "resume" | "fork"
  // event.previousSessionFile: set for "new", "resume", "fork"
});
```
  Migration: SDK session replacement
  
  Before:
```
await session.newSession();
await session.switchSession("/path/to/session.jsonl");
```
  After:
```
import {
  type CreateAgentSessionRuntimeFactory,
  createAgentSessionFromServices,
  createAgentSessionRuntime,
  createAgentSessionServices,
  getAgentDir,
  SessionManager,
} from "@mariozechner/pi-coding-agent";

const createRuntime: CreateAgentSessionRuntimeFactory = async ({ cwd, sessionManager, sessionStartEvent }) => {
  const services = await createAgentSessionServices({ cwd });
  return {
    ...(await createAgentSessionFromServices({ services, sessionManager, sessionStartEvent })),
    services,
    diagnostics: services.diagnostics,
  };
};

const runtime = await createAgentSessionRuntime(createRuntime, {
  cwd: process.cwd(),
  agentDir: getAgentDir(),
  sessionManager: SessionManager.create(process.cwd()),
});

await runtime.newSession();
await runtime.switchSession("/path/to/session.jsonl");
await runtime.fork("entry-id");

// After replacement, runtime.session is the new live session.
// Rebind any session-local subscriptions or extension bindings.
```
  Added
  - Added createAgentSessionRuntime() and AgentSessionRuntime for runtime-backed session replacement. The runtime takes a CreateAgentSessionRuntimeFactory closure that closes over process-global fixed inputs and recreates cwd-bound services and session config for each effective cwd. Startup and later /new, /resume, /fork, import all use the same factory.
  - Added unified diagnostics model (info/warning/error) for arg parsing, service creation, session option resolution, and resource loading. Creation logic no longer logs or exits. The app layer decides presentation and exit behavior.
  - Added error diagnostics for missing explicit CLI resource paths (-e, --skill, --prompt-template, --theme)
  - Added defineTool() so standalone and array-based custom tool definitions keep inferred parameter types without manual casts (#2746)
  - Added label timestamps to the session tree with a Shift+T toggle in /tree, smart date formatting, and timestamp preservation through branching (#2691 by @w-winter)
  Fixed
  - Fixed startup resource loading to reuse the initial ResourceLoader for the first runtime, so extensions are not loaded twice before session startup and session_start handlers still fire for singleton-style extensions (#2766)
  - Fixed retry settlement so retried agent runs wait for the full retry cycle to complete before declaring idle, preventing stale state after transient errors
  - Fixed theme export colors to resolve theme variables the same way as colors, so /export HTML backgrounds now honor entries like pageBg: "base" instead of requiring inline hex values (#2707)
  - Fixed Bedrock throttling errors being misidentified as context overflow, causing unnecessary compaction instead of retry (#2699 by @xu0o0)
  - Added tool streaming support for newer Z.ai models (#2732 by @kaofelix)
8. 🔗 solemnwarning/rehex 0.64.0 release
  
  Release 0.64.0
9. 🔗 r/Yorkshire Bradford Council grants aim to bring 'cafe culture' to city centre rss
  
  | City centre businesses have been awarded grants to allow them to invest in outdoor seating areas and bring "café culture" to Bradford. Six businesses including pubs and cafes received funding from Bradford Council to install outdoor furniture and equipment "to help the visitor economy" in the pedestrianised city centre, the authority said. The grants, totalling about £18,000, have helped the businesses expand their offer by using outside spaces on the newly traffic-free areas such as Market Street and Bridge Street. The pilot scheme has now been extended for a further six months to give other businesses in the area the opportunity to apply for funding. Businesses awarded funding so far this year are: The Exchange Craft Beer House, SAPA Supermarket and The Old Bank pub, all on Market Street. The Ginger Goose pub on the corner of Market Street and Bridge Street, and both Tiffin Coffee and Lela's Café on Bank Street were also part of the scheme. Businesses purchased items such as tables and chairs, planters, signage, lighting and cover installation costs... Eligible businesses on Market Street, Bank Street, Broadway, Bridge Street, Hall Ings and Tyrrel Street can apply for funding. Grants between £500 and £3,000 are available, providing up to 90% of the total cost of the equipment. The lengthy project to pedestrianise a swathe of city centre streets was completed last spring, and several traders have already introduced outdoor seating. In 2025, an outdoor seating area was introduced at the cafe at St George's Hall on Hall Ings. submitted by /u/coffeewalnut08
  [link] [comments]
  ---|---
10. 🔗 r/wiesbaden Suche 1ZW oder WG Zimmer / Looking for studio apartment or room in a shared apartment rss
  
  Englisch below.
  
  Hallo an alle, ich (w34) suche ab August/September eine 1-ZW oder WG Zimmer.
  
  Anfangs als Alternative zum pendeln, später aber auch als Hauptwohnsitz.
  
  Bin unbefristet angestellt, habe einen Hund. Daran scheitert es oft.
  
  Mein Hund ist super lieb und ruhig. Rassetypisch verhält sie sich zuhause eher wie eine Katze.
  
  Vielleicht findet sich ja jemand der jemanden kennt der jemanden kennt.
  
  Wiesbaden/Mainz-Kastell wäre mir am liebsten.
  
  Bei den Spritpreisen ist eine Zweitwohnung von den Kosten fast gleichauf mit dem Pendeln. Danke!
  
  Hello everyone, I (34-year-old woman) am looking for a studio apartment or a room in a shared apartment starting in August/September.
  
  Initially as an alternative to commuting, but later also as my primary residence.
  
  I have a permanent job and a dog. That’s often a dealbreaker.
  
  My dog is super sweet and calm. True to her breed, she acts more like a cat at home.
  
  Maybe someone here knows someone who knows someone.
  
  I’d prefer Wiesbaden or Mainz-Kastell.
  
  With gas prices these days, the cost of a second apartment is almost the same as commuting. Thanks!
  
  submitted by /u/Ok_Historian8945
  [link] [comments]
11. 🔗 The Pragmatic Engineer The Pulse: is GitHub still best for AI-native development? rss
  Hi, this is Gergely with a bonus, free issue of the Pragmatic Engineer Newsletter. In every issue, I cover Big Tech and startups through the lens of senior engineers and engineering leaders. Today, we cover one out of four topics from last week 's The Pulse issue. Full subscribers received the article below eight days ago. If you 've been forwarded this email, you can subscribe here .
  
  We're used to highly reliable systems which target four-nines of availability (99.99%, meaning about 52 minutes of downtime per year), and for it to be embarrassing to barely hit three nines (around 9 hours of downtime per year.) And yet, in the past month, GitHub's reliability is down to one nine!
  
  Here's data from the third-party, "missing GitHub status page", which was built after GitHub stopped updating its own status page due to terrible availability. Recently, things have looked poor:
  
  GitHub down at one nine. Source:The Missing GitHub Status Page
  
  This means that for every 30 days, GitHub had issues on 3 days, or issues/degradations for 2.5 hours daily (around 10% of the time.)
  
  GitHub seems unable to keep up with the massive increase in infra load from agents. One software engineer built a clever website called "Claude's Code" that tracks Claude Code bot contributions across GitHub. Growth in the past three months has been enormous:
  
  Load from Claude Code has 6x 'd in 3 months. Source: Claude 's Code
  
  Stream of GitHub outages from infra overload
  
  GitHub's CTO, Vladimir Fedorov, addressed availability issues in a blog post and covered three major incidents:
  - 2 February: security policies unintentionally blocked access to virtual machine metadata
  - 9 February: a database cluster got overloaded
  - 5 March: writes failed on a Redis cluster
  Software engineer Lori Hochstein did a helpful analysis of these outages and the CTO's response, and has interesting observations:
  - Saturation : the database cluster incident (9 Feb) was a case of the database getting saturated, due to higher-than-expected usage. Databases are harder to scale up than stateless services. GitHub also underestimated how much additional traffic there would be.
  - Failover + telemetry gap : the 2 Feb incident was a combination of an infra issue in one region failing over to a healthy region, and making things worse with a telemetry gap (incorrect security policies were applied in the new regions which blocked access to VM metadata)
  - Failover + configuration issue : the 5 March incident was uncannily similar: after a failover, a configuration issue blocked writes on a Redis cluster
  It is certainly nice to get details from GitHub on these outages. It feels to me that infra strains are causing more infra issues -> they trigger constraints faster -> failovers are not as smooth as they should be. Could it be because GitHub keeps changing their existing systems?
  
  Startup shows GitHub how it's done
  
  While GitHub struggles to keep up with the increase in load from AI agents generating more code and pull requests, a new startup called Pierre Computer claims to have built an "AI-native" solution for AI agents pushing code, which scales far beyond what GitHub can do. Pierre was founded by Jacob Thornton: formerly an engineer at Coinbase, Medium, and Twitter, and also the creator of the once-very popular Bootstrap CSS library.
  
  Here's what Pierre supports, which GitHub does not:
  
  "In October [2025], Github shared they were averaging ~230 new repos per minute.
  
  Last week we [at Pierre Computer] hit a sustained peak of > 15,000 repos per minute for 3 hours.
  
  And in the last 30 days customers have created > 9M repos"
  
  These are incredible numbers - if also self-reported - and something that GitHub clearly cannot get close to, at least not today! There are few details about customers, while the product - called Code.storage - seems to be in closed beta.
  
  Still, this is the type of "git for AI agents" that GitHub has failed to build, and the type of infrastructure it needs badly.
  
  Has GitHub lost focus and purpose?
  
  GitHub's reliability issues are acute enough that, if it keeps up, teams will start giving alternatives like small startups such as Pierre a try, or perhaps even consider self-hosting Git. But how did the largest Git host in the world neglect its customers, and fail to prepare its infra for an increase in code commits and pull requests?
  
  Mitchell Hashimoto, founder of Ghostty, and a heavy user of GitHub himself, had advice on what he would do if he was in charge of GitHub, after growing frustrated with the state of its core offering. He writes (emphasis mine)
  
  "Here's what I'd do if I was in charge of GitHub, in order:
  
  1. Establish a North Star plan around being critical infrastructure for agentic code lifecycles and determine a set of ways to measure that.
  
  2. Fire everyone who works on or advocates for Copilot and shut it down. It's not about the people, I'm sure there's many talented people; you're just working at the wrong company.
  
  3. Buy Pierre and launch agentic repo hosting as the first agentic product. Repos would be separate from the legacy web product to start, since they're likely burdened with legacy cross product interactions.
  
  4. Re-evaluate all product lines and initiatives against the new North Star. I suspect 50% get cut (to make room for different ones).
  
  The big idea is all agentic interactions should critically rely on GitHub APIs. Code review should be agentic but the labs should be building that into GH (not bolted in through GHA like today, real first class platform primitives). GH should absolutely launch an agent chat primitive, agent mailboxes are obviously good. GH should be a platform and not an agent itself.
  
  This is going to be very obviously lacking since I only have external ideas to work off of and have no idea how GitHub internals are working, what their KPIs are or what North Star they define, etc.
  
  But, with imperfect information, this is what I'd do."
  
  My sense is that GitHub has three concurrent problems:
  - GitHub and Copilot are entangled with Microsoft 's internal politics. GitHub's Copilot in 2021 was the first massively successful "AI product." Microsoft took the "Copilot" brand and used it across all of their product lines, creating low-quality AI integrations. Simultaneously, internal Microsoft orgs like Azure and Microsoft AI were trying to get their hands on GitHub, which is one of the most positive developer brands at Microsoft.
  - GitHub has no leader, seemingly by design. GitHub's last CEO was Thomas Dohmke, who stepped down voluntarily, and Microsoft never backfilled the CEO role; instead carrying out a reorg to make GitHub part of Microsoft's AI group and stripping its independence. It seems the "Microsoft AI" side won that battle.
  - GitHub has no focus, and is stuck chasing Copilot as a revenue source. GitHub has no CEO and is caught up in internal politics, so, what can GitHub teams do? The safest bet is to increase revenue and the best way to do that is by investing more into GitHub Copilot, and ignoring long-term issues like reliability.
  I agree with Mitchell: GitHub has no "North Star" and we see a large org being dysfunctional. That lack of vision - and CEO - is hitting hard:
  - GitHub Copilot went from the most-used AI agent in 2021, to be overtaken by Claude Code, and is soon to be overtaken by Cursor.
  - As a platform, GitHub has no vision for how to evolve to support AI agents. Sure, GitHub has an MCP server, but it has no "AI-native git platform" that can handle the massive load AI agents generate.
  - GitHub keeps shipping small features and improvements without direction. For example, in October 2025, they started to work on stacked diffs. However, when it ships, the stacked diffs workflow might be mostly obsolete - at least with AI agents!
  It's easy to win a market when you do one thing better than anyone else in the world. Right now, GitHub is doing too many things and doing a subpar job with Copilot, its platform, and AI infra.
  
  Read the full issue of last week's The Pulse, or check out this week's The Pulse.
  
  Catch up with recent The Pragmatic Engineer issues:
  - Scaling Uber with Thuan Pham (Uber's first CTO -- podcast). We went into topics like scaling Uber from constant outages to global infrastructure, the shift to microservices and platform teams, and how AI is reshaping engineering.
  - Building WhatsApp with Jean Lee (podcast): Jean Lee, engineer #19 at WhatsApp, on scaling the app with a tiny team, the Facebook acquisition, and what it reveals about the future of engineering.
  - What will the Staff Engineer role look like in 2027 and beyond? What happens to the Staff engineer role when agents write more code? Actually, they could be more in demand than ever!
12. 🔗 r/york Greyhound walk still on this Easter weekend? rss
  
  I wanted to take my boy on the Greyhound Walk for the first time. I know it takes place on the first Sunday of the month, but as it's Easter Sunday I don't know if it's still going ahead?
  
  submitted by /u/peachranunculus
  [link] [comments]
13. 🔗 @binaryninja@infosec.exchange Who needs containers? You do! If you reverse firmware, macho files, malware, mastodon
  
  Who needs containers? You do! If you reverse firmware, macho files, malware, or many other formats! Come see what's unlocked in Binary Ninja by this feature in our latest blog post from Brian:
  
  https://binary.ninja/2026/03/31/container- transforms.html
14. 🔗 r/Harrogate Empty Chairs - Wednesday 8th April rss
  
  | https://emptychairs.org.uk Empty Chairs is a simple idea: each evening we book a small table in a pub and leave a few chairs empty - inviting anyone who wants company to join us. There's no pressure, no agenda, and no expectation to stay longer than you want. I'll be hosting an event at Major Tom Social in Harrogate on Wednesday 8th April at 6pm till whenever! In the spirit of the campaign I'll be wearing a bright orange t-shirt; hope to see some of you there! submitted by /u/LectricVersion
  [link] [comments]
  ---|---
15. 🔗 Evan Schwartz Scour - March Update rss
  Hi friends,
  
  In March, Scour scoured 813,588 posts from 24,029 feeds (7,131 were newly added) and 488 new users signed up. Welcome!
  
  Here's what's new in the product:
  
  🔃 Feed Diversity Overhaul
  
  Scour now does a better job of ensuring that your feed draws from a mix of sources and that no single interest or group of interests dominates. I had made a number of changes along these lines in the past, but they were fiddly and the diversification mechanism wasn't working that well. Under the hood, Scour now does a first pass to score how similar articles are to your interests and then has a separate step for selecting posts for your feed while keeping it diverse on a number of different dimensions.
  
  🥰 More of What You Like
  
  Content from websites and groups of interests you tend to like and/or click on more are now given slightly more room in your feed. Conversely, websites and groups of interests you tend to dislike or not click on will be given a bit less space.
  
  For Scour, I'm always trying to think of how to show you more content you'll find interesting -- without trapping you in a small filter bubble (you can read about my ranking philosophy in the docs). After a number of iterations, I landed on a design that I'm happy with. I hope this strikes a good balance between making sure you see articles from your favorite sources, while still leaving room for the serendipity of finding a great new source that you didn't know existed.
  
  ❤️ Inline Reactions
  
  After you click an article, Scour now explicitly asks you for your reaction. These reactions help tune your feed slightly, and they help me improve the ranking algorithm over time. Before, the reaction buttons were below every post but that made them a bit hard to hit intentionally and easy to touch accidentally. If you want to react to an article without reading it first, you can also find them in the More Options (...) menu.
  
  Thanks to Shane Sveller for pointing out that the reaction buttons were too small on mobile!
  
  🎯 Exact Keyword Matching
  
  Scour now supports exact keyword matching, in addition to using vector embeddings for semantic similarity. Articles that are similar to one of your interests but don't use the exact words or phrases from your interest definition will be ranked lower. Right now this applies to interests marked as "Specific" or "Normal" (this is also automatically determined when interests are created). This should cut down on the number of articles you see that are mis-categorized or clearly off-topic.
  
  Thanks to Alex Miller and an anonymous user for prompting this, and thanks to Alex, JackJackson, mhsid, snuggles, and anders_no for all the Off-Topic reports!
  
  ⁉️ Why Didn't This Appear?
  
  Sometimes, I see an article on Hacker News or elsewhere and wonder why didn't this show up in my Scour feed. You can now paste links into the Why didn't I see this? page, and it will give you a bit of an explanation. You can also report that so I can look into it more and continue to improve the ranking algorithm over time.
  
  🔖 Some of My Favorite Posts
  
  Here were some of my favorite posts that I found on Scour in March:
  - For anyone building products, this is a good reminder to make sure you're trying out and experiencing the bad parts of your product: Bored of eating your own dogfood? Try smelling your own farts!.
  - This was a brief, interesting history and technical overview of document formats, from .doc to .docx and .odf and why Markdown "won": Markdown Ate The World.
  - A reminder that any user-generated input, including repo branch names, can be malicious: OpenAI Codex: How a Branch Name Stole GitHub Tokens.
  - This is a very detailed and informative visual essay explaining how quantization (compression) for large language models works: Quantization from the ground up.
  - I'm not currently using Turso (the Rust rewrite of SQLite), but I think what they're doing is interesting. Including this experimental version that speaks the Postgres SQL dialect: pgmicro.
  - And because I like making -- and eating -- sour sourdough: How To Make Sourdough Bread More (Or Less) Sour.
  Happy Scouring!
  
  - Evan
  
  P.S. If you use a coding agent like Claude Code, I also wrote up A Rave Review of Superpowers, a plugin that makes me much more productive.
16. 🔗 r/Leeds Delivery guy left the gate open, now there’s an old, sort of deaf and very silly dog on the loose. Anyone seen owt? rss
  
  if anyone has seen little edwina please give us a shout. most likely around Middleton area 🙏
  
  submitted by /u/RoyaleForFree
  [link] [comments]
17. 🔗 Simon Willison The Axios supply chain attack used individually targeted social engineering rss
  The Axios team have published a full postmortem on the supply chain attack which resulted in a malware dependency going out in a release the other day, and it involved a sophisticated social engineering campaign targeting one of their maintainers directly. Here's Jason Saayman'a description of how that worked:
  so the attack vector mimics what google has documented here: https://cloud.google.com/blog/topics/threat-intelligence/unc1069-targets-cryptocurrency-ai-social-engineering
  
  they tailored this process specifically to me by doing the following:
  
  they reached out masquerading as the founder of a company they had cloned the companys founders likeness as well as the company itself.
  
  they then invited me to a real slack workspace. this workspace was branded to the companies ci and named in a plausible manner. the slack was thought out very well, they had channels where they were sharing linked-in posts, the linked in posts i presume just went to the real companys account but it was super convincing etc. they even had what i presume were fake profiles of the team of the company but also number of other oss maintainers.
  
  they scheduled a meeting with me to connect. the meeting was on ms teams. the meeting had what seemed to be a group of people that were involved.
  
  the meeting said something on my system was out of date. i installed the missing item as i presumed it was something to do with teams, and this was the RAT.
  
  everything was extremely well co-ordinated looked legit and was done in a professional manner.
  A RAT is a Remote Access Trojan - this was the software which stole the developer's credentials which could then be used to publish the malicious package.
  
  That's a very effective scam. I join a lot of meetings where I find myself needing to install Webex or Microsoft Teams or similar at the last moment and the time constraint means I always click "yes" to things as quickly as possible to make sure I don't join late.
  
  Every maintainer of open source software used by enough people to be worth taking in this way needs to be familiar with this attack strategy.
  
  You are only seeing the long-form articles from my blog. Subscribe to /atom/everything/ to get all of my posts, or take a look at my other subscription options.
18. 🔗 r/Yorkshire Yorkshire Coast Kite Festival, with some of the world’s largest kites is to return this spring. rss
  
  | submitted by /u/ScrollAndThink
  [link] [comments]
  ---|---
19. 🔗 Textualize/textual The Faster Resize Release release
  Fixed an issue where styles were being unneccesarily updated when resizing. Textual apps will now adapt to changes in the terminal size much more quickly.
  
  [8.2.2] - 2026-04-03
  
  Fixed
  - Fixed Pointless style updates when resizing #6464
20. 🔗 Anton Zhiyanov Porting Go's strings package to C rss
  Creating a subset of Go that translates to C was never my end goal. I liked writing C code with Go, but without the standard library it felt pretty limited. So, the next logical step was to port Go's stdlib to C.
  
  Of course, this isn't something I could do all at once. I started with the io package, which provides core abstractions like Reader and Writer, as well as general-purpose functions like Copy. But io isn't very interesting on its own, since it doesn't include specific reader or writer implementations. So my next choices were naturally bytes and strings — the workhorses of almost every Go program. This post is about how the porting process went.
  
  Bits and UTF-8 • Bytes • Allocators • Buffers and builders • Benchmarks • Optimizing search • Optimizing builder • Wrapping up
  
  Bits and UTF-8
  
  Before I could start porting bytes, I had to deal with its dependencies first:
  - math/bits implements bit counting and manipulation functions.
  - unicode/utf8 implements functions for UTF-8 encoded text.
  Both of these packages are made up of pure functions, so they were pretty easy to port. The only minor challenge was the difference in operator precedence between Go and C — specifically, bit shifts (<<, >>). In Go, bit shifts have higher precedence than addition and subtraction. In C, they have lower precedence:
```
// Go: shift has HIGHER precedence than +
var x uint32 = 1<<2 + 3  // (1 << 2) + 3 == 7



// C: shift has LOWER precedence than +
uint32_t x = 1 << 2 + 3; // 1 << (2 + 3) == 32
```
  The simplest solution was to just use parentheses everywhere shifts are involved:
```
// Go: Mul64 returns the 128-bit product of x and y: (hi, lo) = x * y
func Mul64(x, y uint64) (hi, lo uint64) {
    const mask32 = 1<<32 - 1
    x0 := x & mask32
    x1 := x >> 32
    y0 := y & mask32
    y1 := y >> 32
    w0 := x0 * y0
    t := x1*y0 + w0>>32
    // ...
}



// C: Mul64 returns the 128-bit product of x and y: (hi, lo) = x * y
so_Result bits_Mul64(uint64_t x, uint64_t y) {
    const so_int mask32 = ((so_int)1 << 32) - 1;
    uint64_t x0 = (x & mask32);
    uint64_t x1 = (x >> 32);
    uint64_t y0 = (y & mask32);
    uint64_t y1 = (y >> 32);
    uint64_t w0 = x0 * y0;
    uint64_t t = x1 * y0 + (w0 >> 32);
    // ...
}
```
  With bits and utf8 done, I moved on to bytes.
  
  Bytes
  
  The bytes package provides functions for working with byte slices:
```
// Count counts the number of non-overlapping instances of sep in s.
func Count(s, sep []byte) int

// Equal reports whether a and b are the
// same length and contain the same bytes.
func Equal(a, b []byte) bool

// Index returns the index of the first instance
// of sep in s, or -1 if sep is not present in s.
func Index(s, sep []byte) int

// Repeat returns a new byte slice consisting of count copies of b.
func Repeat(b []byte, count int) []byte

// and others
```
  Some of them were easy to port, like Equal. Here's how it looks in Go:
```
// Equal reports whether a and b are the
// same length and contain the same bytes.
func Equal(a, b []byte) bool {
    // Neither cmd/compile nor gccgo allocates for these string conversions.
    return string(a) == string(b)
}
```
  And here's the C version:
```
// bytes_string reinterprets a byte slice as a string (zero-copy).
#define so_bytes_string(bs) ({                  \
    so_Slice _bs = (bs);                        \
    (so_String){(const char*)_bs.ptr, _bs.len}; \
})

// string_eq returns true if two strings are equal.
static inline bool so_string_eq(so_String s1, so_String s2) {
    return s1.len == s2.len &&
        (s1.len == 0 || memcmp(s1.ptr, s2.ptr, s1.len) == 0);
}

// Equal reports whether a and b are the
// same length and contain the same bytes.
bool bytes_Equal(so_Slice a, so_Slice b) {
    return so_string_eq(so_bytes_string(a), so_bytes_string(b));
}
```
  Just like in Go, the so_bytes_string ([]byte → string) macro doesn't allocate memory; it just reinterprets the byte slice's underlying storage as a string. The so_string_eq function (which works like == in Go) is easy to implement using memcmp from the libc API.
  
  Another example is the IndexByte function, which looks for a specific byte in a slice. Here's the pure-Go implementation:
```
// IndexByte returns the index of the first instance
// of c in b, or -1 if c is not present in b.
func IndexByte(b []byte, c byte) int {
    for i, x := range b {
        if x == c {
            return i
        }
    }
    return -1
}
```
  And here's the C version:
```
// IndexByte returns the index of the first instance
// of c in b, or -1 if c is not present in b.
so_int bytes_IndexByte(so_Slice b, so_byte c) {
    for (so_int i = 0; i < so_len(b); i++) {
        so_byte x = so_at(so_byte, b, i);
        if (x == c) {
            return i;
        }
    }
    return -1;
}
```
  I used a regular C for loop to mimic Go's for-range:
  - Loop over the slice indexes with for (so_len is a macro that returns b.len, similar to Go's len built-in).
  - Access the i-th byte with so_at (a bounds-checking macro that returns *((so_byte*)b.ptr + i)).
  But Equal and IndexByte don't allocate memory. What should I do with Repeat, since it clearly does? I had a decision to make.
  
  Allocators
  
  The Go runtime handles memory allocation and deallocation automatically. In C, I had a few options:
  - Use a reliable garbage collector like Boehm GC to closely match Go's behavior.
  - Allocate memory with libc's malloc and have the caller free it later with free.
  - Introduce allocators.
  An allocator is a tool that reserves memory (typically on the heap) so a program can store its data structures there. See Allocators from C to Zig if you want to learn more about them.
  
  For me, the winner was clear. Modern systems programming languages like Zig and Odin clearly showed the value of allocators:
  - It's obvious whether a function allocates memory or not: if it has an allocator as a parameter, it allocates.
  - It's easy to use different allocation methods: you can use malloc for one function, an arena for another, and a stack allocator for a third.
  - It helps with testing and debugging: you can use a tracking allocator to find memory leaks, or a failing allocator to test error handling.
  An Allocator is an interface with three methods: Alloc, Realloc, and Free. In C, it translates to a struct with function pointers:
```
// Allocator defines the interface for memory allocators.
typedef struct {
    void* self;
    so_Result (*Alloc)(void* self, so_int size, so_int align);
    so_Result (*Realloc)(void* self, void* ptr,
        so_int oldSize, so_int newSize, so_int align);
    void (*Free)(void* self, void* ptr, so_int size, so_int align);
} mem_Allocator;
```
  As I mentioned in the post about porting the io package, this interface representation isn't as efficient as using a static method table, but it's simpler. If you're interested in other options, check out the post on interfaces.
  
  By convention, if a function allocates memory, it takes an allocator as its first parameter. So Go's Repeat:
```
// Repeat returns a new byte slice consisting of count copies of b.
func Repeat(b []byte, count int) []byte
```
  Translates to this C code:
```
// Repeat returns a new byte slice consisting of count copies of b.
//
// If the allocator is nil, uses the system allocator.
// The returned slice is allocated; the caller owns it.
so_Slice bytes_Repeat(mem_Allocator a, so_Slice b, so_int count)
```
  If the caller doesn't care about using a specific allocator, they can just pass an empty allocator, and the implementation will use the system allocator — calloc, realloc, and free from libc.
  
  Here's a simplified version of the system allocator (I removed safety checks to make it easier to read):
```
// SystemAllocator uses the system's malloc, realloc, and free functions.
// It zeros out new memory on allocation and reallocation.
typedef struct {} mem_SystemAllocator;

so_Result mem_SystemAllocator_Alloc(void* self, so_int size, so_int align) {
    void* ptr = calloc(1, (size_t)(size));
    if (ptr == NULL) {
        return (so_Result){.val.as_ptr = NULL, .err = mem_ErrOutOfMemory};
    }
    return (so_Result){ .val.as_ptr = ptr, .err = NULL};
}

so_Result mem_SystemAllocator_Realloc(void* self, void* ptr, so_int oldSize,
    so_int newSize, so_int align) {
    void* newPtr = realloc(ptr, (size_t)(newSize));
    if (newPtr == NULL) {
        return (so_Result){.val.as_ptr = NULL, .err = mem_ErrOutOfMemory};
    }
    if (newSize > oldSize) {
        // Zero new memory beyond the old size.
        memset((char*)newPtr + oldSize, 0, (size_t)(newSize - oldSize));
    }
    return (so_Result){.val.as_ptr = newPtr, .err = NULL};
}

void mem_SystemAllocator_Free(void* self, void* ptr, so_int size, so_int align) {
    free(ptr);
}
```
  The system allocator is stateless, so it's safe to have a global instance:
```
// System is an instance of a memory allocator that uses
// the system's malloc, realloc, and free functions.
mem_Allocator mem_System = {
    .self = &(mem_SystemAllocator){},
    .Alloc = mem_SystemAllocator_Alloc,
    .Free = mem_SystemAllocator_Free,
    .Realloc = mem_SystemAllocator_Realloc};
```
  Here's an example of how to call Repeat with an allocator:
```
so_Slice src = so_string_bytes(so_str("abc"));
so_Slice got = bytes_Repeat(mem_System, src, 3);
so_String gotStr = so_bytes_string(got);
if (so_string_ne(gotStr, so_str("abcabcabc"))) {
    so_panic("want Repeat(abc) == abcabcabc");
}
mem_FreeSlice(so_byte, mem_System, got);
```
  Way better than hidden allocations!
  
  Buffers and builders
  
  Besides pure functions, bytes and strings also provide types like bytes.Buffer, bytes.Reader, and strings.Builder. I ported them using the same approach as with functions.
  
  For types that allocate memory, like Buffer, the allocator becomes a struct field:
```
// A Buffer is a variable-sized buffer of bytes
// with Read and Write methods.
typedef struct {
    mem_Allocator a;
    so_Slice buf;
    so_int off;
} bytes_Buffer;



// Usage example.
bytes_Buffer buf = bytes_NewBuffer(mem_System, (so_Slice){0});
bytes_Buffer_WriteString(&buf, so_str("hello"));
bytes_Buffer_WriteString(&buf, so_str(" world"));
so_String str = bytes_Buffer_String(&buf);
if (so_string_ne(str, so_str("hello world"))) {
    so_panic("Buffer.WriteString failed");
}
bytes_Buffer_Free(&buf);
```
  The code is pretty wordy — most C developers would dislike using bytes_Buffer_WriteString instead of something shorter like buf_writestr. My solution to this problem is to automatically translate Go code to C (which is actually what I do when porting Go's stdlib). If you're interested, check out the post about this approach — Solod: Go can be a better C.
  
  Types that don't allocate, like bytes.Reader, need no special treatment — they translate directly to C structs without an allocator field.
  
  The strings package is the twin of bytes, so porting it was uneventful. Here's strings.Builder usage example in Go and C side by side:
```
// go
var sb strings.Builder
sb.WriteString("Hello")
sb.WriteByte(',')
sb.WriteRune(' ')
sb.WriteString("world")
s := sb.String()
if s != "Hello, world" {
    panic("want sb.String() == 'Hello, world'")
}



// c
strings_Builder sb = {.a = mem_System};
strings_Builder_WriteString(&sb, so_str("Hello"));
strings_Builder_WriteByte(&sb, ',');
strings_Builder_WriteRune(&sb, U' ');
strings_Builder_WriteString(&sb, so_str("world"));
so_String s = strings_Builder_String(&sb);
if (so_string_ne(s, so_str("Hello, world"))) {
    so_panic("want sb.String() == 'Hello, world'");
}
strings_Builder_Free(&sb);
```
  Again, the C code is just a more verbose version of Go's implementation, plus explicit memory allocation.
  
  Benchmarks
  
  What's the point of writing C code if it's slow, right? I decided it was time to benchmark the ported C types and functions against their Go versions.
  
  To do that, I ported the benchmarking part of Go's testing package. Surprisingly, the simplified version was only 300 lines long and included everything I needed:
  - Figuring out how many iterations to run.
  - Running the benchmark function in a loop.
  - Recording metrics (ns/op, MB/s, B/op, allocs/op).
  - Reporting the results.
  Here's a sample benchmark for the strings.Builder type:
```
static so_String someStr = so_str("some string sdljlk jsklj3lkjlk djlkjw");
static const so_int numWrite = 16;
volatile so_String sink = {0};

void main_WriteString_AutoGrow(testing_B* b) {
    mem_Allocator a = testing_B_Allocator(b);
    for (; testing_B_Loop(b);) {
        strings_Builder sb = strings_NewBuilder(a);
        for (so_int i = 0; i < numWrite; i++) {
            strings_Builder_WriteString(&sb, someStr);
        }
        sink = strings_Builder_String(&sb);
        strings_Builder_Free(&sb);
    }
}

// more benchmarks...
```
  Reads almost like Go's benchmarks.
  
  To monitor memory usage, I created Tracker — a memory allocator that wraps another allocator and keeps track of allocations:
```
// A Stats records statistics about the memory allocator.
typedef struct {
    uint64_t Alloc;
    uint64_t TotalAlloc;
    uint64_t Mallocs;
    uint64_t Frees;
} mem_Stats;

// A Tracker wraps an Allocator and tracks all
// allocations and deallocations made through it.
typedef struct {
    mem_Allocator Allocator;
    mem_Stats Stats;
} mem_Tracker;

so_Result mem_Tracker_Alloc(void* self, so_int size, so_int align) {
    mem_Tracker* t = self;
    so_Result res = t->Allocator.Alloc(t->Allocator.self, size, align);
    // ...
    t->Stats.Alloc += (uint64_t)(size);
    t->Stats.TotalAlloc += (uint64_t)(size);
    t->Stats.Mallocs++;
    return (so_Result){.val.as_ptr = res.val.as_ptr, .err = NULL};
}

void mem_Tracker_Free(void* self, void* ptr, so_int size, so_int align) {
    mem_Tracker* t = self;
    t->Allocator.Free(t->Allocator.self, ptr, size, align);
    t->Stats.Alloc -= (uint64_t)(size);
    t->Stats.Frees++;
}
```
  The benchmark gets an allocator through the testing_RunBenchmarks function and wraps it in a Tracker to keep track of allocations:
```
int main(void) {
    so_Slice benchs = {(testing_Benchmark[4]){
        {.Name = so_str("WriteS_AutoGrow"), .F = main_WriteString_AutoGrow},
        {.Name = so_str("WriteS_PreGrow"), .F = main_WriteString_PreGrow},
        {.Name = so_str("WriteB_AutoGrow"), .F = main_Write_AutoGrow},
        {.Name = so_str("WriteB_PreGrow"), .F = main_Write_PreGrow}},
        4, 4};
    testing_RunBenchmarks(mem_System, benchs);
}
```
  There's no auto-discovery, but the manual setup is quite straightforward.
  
  Optimizing search
  
  With the benchmarking setup ready, I ran benchmarks on the strings package. Some functions did well — about 1.5-2x faster than their Go equivalents:
```
go
Benchmark_Clone-8      12143073      98.50 ns/op    1024 B/op    1 allocs/op
Benchmark_Fields-8       791077    1524 ns/op        288 B/op    1 allocs/op
Benchmark_Repeat-8      9197040     127.3 ns/op     1024 B/op    1 allocs/op

c
Benchmark_Clone        27935466      41.84 ns/op    1024 B/op    1 allocs/op
Benchmark_Fields        1319384     907.7 ns/op      272 B/op    1 allocs/op
Benchmark_Repeat       18445929      64.11 ns/op    1024 B/op    1 allocs/op
```
  But Index (searching for a substring in a string) was a total disaster — it was nearly 20 times slower than in Go:
```
go
Benchmark_Index-8      47874408      25.14 ns/op       0 B/op    0 allocs/op

c
Benchmark_Index          483787     483.1 ns/op        0 B/op    0 allocs/op
```
  The problem was caused by the IndexByte function we looked at earlier:
```
// IndexByte returns the index of the first instance
// of c in b, or -1 if c is not present in b.
func IndexByte(b []byte, c byte) int {
    for i, x := range b {
        if x == c {
            return i
        }
    }
    return -1
}
```
  This "pure" Go implementation is just a fallback. On most platforms, Go uses a specialized version of IndexByte written in assembly.
  
  For the C version, the easiest solution was to use memchr, which is also optimized for most platforms:
```
static inline so_int bytealg_IndexByte(so_Slice b, so_byte c) {
    void* at = memchr(b.ptr, (int)c, b.len);
    if (at == NULL) return -1;
    return (so_int)((char*)at - (char*)b.ptr);
}
```
  With this fix, the benchmark results changed drastically:
```
go
Benchmark_Index-8        47874408    25.14 ns/op    0 B/op    0 allocs/op
Benchmark_IndexByte-8    54982188    21.98 ns/op    0 B/op    0 allocs/op

c
Benchmark_Index          33552540    35.21 ns/op    0 B/op    0 allocs/op
Benchmark_IndexByte      36868624    32.81 ns/op    0 B/op    0 allocs/op
```
  Still not quite as fast as Go, but it's close. Honestly, I don't know why the memchr-based implementation is still slower than Go's assembly here, but I decided not to pursue it any further.
  
  After running the rest of the strings function benchmarks, the ported versions won all of them except for two:
  
  Benchmark | Go | C (mimalloc) | C (arena) | Winner
  ---|---|---|---|---
  Clone | 99ns | 42ns | 34ns | C - 2.4x
  Compare | 47ns | 36ns | 36ns | C - 1.3x
  Fields | 1524ns | 908ns | 912ns | C - 1.7x
  Index | 25ns | 35ns | 34ns | Go - 0.7x
  IndexByte | 22ns | 33ns | 33ns | Go - 0.7x
  Repeat | 127ns | 64ns | 67ns | C - 1.9x
  ReplaceAll | 243ns | 200ns | 203ns | C - 1.2x
  Split | 1899ns | 1399ns | 1423ns | C - 1.3x
  ToUpper | 2066ns | 1602ns | 1622ns | C - 1.3x
  Trim | 501ns | 373ns | 375ns | C - 1.3x
  
  Benchmarking details
  
  Optimizing builder
  
  strings.Builder is a common way to compose strings from parts in Go, so I tested its performance too. The results were worse than I expected:
```
go
Benchmark_WriteS_AutoGrow-8   5385492   224.0 ns/op   1424 B/op   5 allocs/op
Benchmark_WriteS_PreGrow-8   10692721   112.9 ns/op    640 B/op   1 allocs/op

c
Benchmark_WriteS_AutoGrow     5659255   212.9 ns/op   1147 B/op   5 allocs/op
Benchmark_WriteS_PreGrow      9811054   122.1 ns/op    592 B/op   1 allocs/op
```
  Here, the C version performed about the same as Go, but I expected it to be faster. Unlike Index, Builder is written entirely in Go, so there's no reason the ported version should lose in this benchmark.
  
  The WriteString method looked almost identical in Go and C:
```
// WriteString appends the contents of s to b's buffer.
// It returns the length of s and a nil error.
func (b *Builder) WriteString(s string) (int, error) {
    b.buf = append(b.buf, s...)
    return len(s), nil
}



static so_Result strings_Builder_WriteString(void* self, so_String s) {
    strings_Builder* b = self;
    strings_Builder_grow(b, so_len(s));
    b->buf = so_extend(so_byte, b->buf, so_string_bytes(s));
    return (so_Result){.val.as_int = so_len(s), .err = NULL};
}
```
  Go's append automatically grows the backing slice, while strings_Builder_grow does it manually (so_extend, on the contrary, doesn't grow the slice — it's merely a memcpy wrapper). So, there shouldn't be any difference. I had to investigate.
  
  Looking at the compiled binary, I noticed a difference in how the functions returned results. Go returns multiple values in separate registers, so (int, error) uses three registers: one for 8-byte int, two for the error interface (implemented as two 8-byte pointers). But in C, so_Result was a single struct made up of two so_Value unions and a so_Error pointer:
```
typedef union {
    bool as_bool;        // 1 byte
    so_int as_int;       // 8 bytes
    int64_t as_i64;      // 8 bytes
    so_String as_string; // 16 bytes (ptr + len)
    so_Slice as_slice;   // 24 bytes (ptr + len + cap)
    void* as_ptr;        // 8 bytes
    // ... other types
} so_Value;

typedef struct {
    so_Value val;        // 24 bytes
    so_Value val2;       // 24 bytes
    so_Error err;        // 8 bytes
} so_Result;
```
  Of course, this 56-byte monster can't be returned in registers — the C calling convention passes it through memory instead. Since WriteString is on the hot path in the benchmark, I figured this had to be the issue. So I switched from a single monolithic so_Result type to signature-specific types for multi- return pairs:
  - so_R_bool_err for (bool, error);
  - so_R_int_err for (so_int, error);
  - so_R_str_err for (so_String, error);
  - etc.
  Now, the Builder.WriteString implementation in C looked like this:
```
typedef struct {
    so_int val;
    so_Error err;
} so_R_int_err;

static so_R_int_err strings_Builder_WriteString(void* self, so_String s) {
    // ...
}
```
  so_R_int_err is only 16 bytes — small enough to be returned in two registers. Problem solved! But it wasn't — the benchmark only showed a slight improvement.
  
  After looking into it more, I finally found the real issue: unlike Go, the C compiler wasn't inlining WriteString calls. Adding inline and moving strings_Builder_WriteString to the header file made all the difference:
```
go
Benchmark_WriteS_AutoGrow-8   5385492   224.0 ns/op   1424 B/op   5 allocs/op
Benchmark_WriteS_PreGrow-8   10692721   112.9 ns/op    640 B/op   1 allocs/op

c
Benchmark_WriteS_AutoGrow    10344024   115.9 ns/op   1147 B/op   5 allocs/op
Benchmark_WriteS_PreGrow     41045286    28.74 ns/op   592 B/op   1 allocs/op
```
  2-4x faster. That's what I was hoping for!
  
  Wrapping up
  
  Porting bytes and strings was a mix of easy parts and interesting challenges. The pure functions were straightforward — just translate the syntax and pay attention to operator precedence. The real design challenge was memory management. Using allocators turned out to be a good solution, making memory allocation clear and explicit without being too difficult to use.
  
  The benchmarks showed that the C versions outperformed Go in most cases, sometimes by 2-4x. The only exceptions were Index and IndexByte, where Go relies on hand-written assembly. The strings.Builder optimization was an interesting challenge: what seemed like a return-type issue was actually an inlining problem, and fixing it gave a nice speed boost.
  
  There's a lot more of Go's stdlib to port. In the next post, we'll cover time — a very unique Go package. In the meantime, if you'd like to write Go that translates to C — with no runtime and manual memory management — I invite you to try Solod. The bytes and strings packages are included, of course.
21. 🔗 r/LocalLLaMA Netflix just dropped their first public model on Hugging Face: VOID: Video Object and Interaction Deletion rss
  
  | Hugging Face netflix/void-model: https://huggingface.co/netflix/void-model Project page - GitHub: https://github.com/Netflix/void-model Demo: https://huggingface.co/spaces/sam-motamed/VOID submitted by /u/Nunki08
  [link] [comments]
  ---|---
22. 🔗 r/reverseengineering Open source runtime that deep-inspects AI agent protocol traffic (MCP/ACP) — Rust rss
  
  submitted by /u/After_Somewhere_2254
  [link] [comments]
23. 🔗 r/wiesbaden Weibliche Freundschaften knüpfen in Wiesbden rss
  
  Bin M26 und seit 6 Jahren in einer Beziehung, suche weibliche Freundschaften, wo klar ist das es nur eine Freundschaft ist.
  
  Ich bin 26 Jahre alt, meine Hobbies sind definitiv das Wandern, Ausgehen, der Reitsport sowie Informatik :)
  
  und generell draußen in der Natur sein!
  
  Man sagt mir oft, dass ich ein ziemlich Empathischer Mensch und guter Zuhörer bin, mit dem man über alles quatschen kann. (Das müsstest du aber selbst herausfinden)
  
  submitted by /u/SuanaT
  [link] [comments]
24. 🔗 r/LocalLLaMA Gemma 4 is fine great even … rss
  
  | Been playing with the new Gemma 4 models it’s amazing great even but boy did it make me appreciate the level of quality the qwen team produced and I’m able to have much larger context windows on my standard consumer hardware. submitted by /u/ThinkExtension2328
  [link] [comments]
  ---|---
25. 🔗 r/Leeds A-W of Leeds: Armley rss
  
  For my free Substack newsletter Bury the Leeds I’m walking through each of the 33 council wards in Leeds, from Adel to Wetherby, one by one, using unusual articles I’ve found from the city’s past as a rough guide.
  
  My fourth walk took me to Armley. I had to start at the most famous postcode in the patch - the prison, which since 1847 has loomed above the city like a threat. I wrote about Emily Swann who was the only woman to be executed there, a few days after Christmas in 1903. Quite a sad tale, that one.
  
  I also discuss a forgetful pieman in the Albion pub, the end of the line for Mollie, the beloved delivery horse of Tong Road and troublesome hobbledehoys in Armley Park.
  
  Next stop is Beeston and Holbeck!
  
  https://burytheleeds.substack.com/p/a-w-of-leeds-armley
  
  Have a solid Easter weekend r/Leeds !
  
  submitted by /u/bluetrainlinesss
  [link] [comments]
26. 🔗 r/york Putting together a cycle parking map rss
  
  Hello!
  
  I've just started cycling again, and realised the bike racks have changed a lot since I last parked my bike in town - I was wondering if anyone can help me pin point where the cycle racks are now in the city centre?
  
  I'm going to create a map for the city centre. I will be out and about checking where they are but if anyone can help me locate them first - that would be great!
  
  submitted by /u/donttrustthellamas
  [link] [comments]
27. 🔗 r/wiesbaden Wo wächst Bärlauch in Wiesbaden? rss
  
  Hey, weiß jemand, wo man in Wiesbaden oder Umgebung Bärlauch finden kann (zum selber pflücken)?
  
  Ich würde gerne damit kochen und wäre für jeden Tipp dankbar 🙏
  
  submitted by /u/Sea_Rip_3269
  [link] [comments]
28. 🔗 r/LocalLLaMA qwen 3.6 voting rss
  
  | I am afraid you have to use X guys https://x.com/ChujieZheng/status/2039909486153089250 submitted by /u/jacek2023
  [link] [comments]
  ---|---
29. 🔗 r/wiesbaden Gute Physiotherapie rss
  
  Hat jemand einen Tipp für gute Physiotherapie in Wiesbaden?
  
  submitted by /u/wuyntmm
  [link] [comments]
30. 🔗 HexRaysSA/plugin-repository commits sync repo: +1 release rss
```
sync repo: +1 release

## New releases
- [vtable-context-tools](https://github.com/oxiKKK/ida-vtable-tools): 1.0.2
```
April 02, 2026
1. 🔗 IDA Plugin Updates IDA Plugin Updates on 2026-04-02 rss
  IDA Plugin Updates on 2026-04-02
  
  New Releases:
  - ghidra-chinese 20260402 - 23908416654
  - ida-vtable-tools 1.0.2
  Activity:
  - augur
    
    73ca57ea: chore: update dependencies
  - ghidra-chinese
    
    02ef89c4: Merge pull request #95 from TC999/sync
  - haruspex
    
    9402b254: chore: update dependencies
  - hrtng
    
    ccb686f7: - "Recast item" improvement
  - ida-vtable-tools
    
    79100769: README
    
    cdfcefff: README
    
    92435b20: README and json
    
    5c5978b0: Merge pull request #1 from oxiKKK/method-annotation
    
    1f53a2ce: Add method annotation
  - rhabdomancer
    
    56c6247b: chore: update dependencies
2. 🔗 r/reverseengineering Reverse engineering workshop in arabic rss
  
  submitted by /u/muxmn
  [link] [comments]
3. 🔗 r/LocalLLaMA One of the best sensible reasons that I can think of to have an llm downloaded on my cell phone would be emergency advice. rss
  
  | It seems like every conversation about derestricted models everyone treat you like a pervert. The fact is you can be sensible and be a pervert 😂. submitted by /u/RedParaglider
  [link] [comments]
  ---|---
4. 🔗 r/wiesbaden looking for rave/party buddies rss
  
  as title says, i am new to raving, and want to start attending more. I currently use Bumble Friends and Radiate, and want to make friends in general. Leave a comment if you know some good places to start as a newbie, or if you are nearby and want to go together
  
  submitted by /u/hunkyyydory
  [link] [comments]
5. 🔗 Simon Willison Highlights from my conversation about agentic engineering on Lenny's Podcast rss
  I was a guest on Lenny Rachitsky's podcast, in a new episode titled An AI state of the union: We've passed the inflection point, dark factories are coming, and automation timelines. It's available on YouTube, Spotify, and Apple Podcasts. Here are my highlights from our conversation, with relevant links.
  The November inflection point
  
  4:19 - The end result of these two labs throwing everything they had at making their models better at code is that in November we had what I call the inflection point where GPT 5.1 and Claude Opus 4.5 came along.
  
  They were both incrementally better than the previous models, but in a way that crossed a threshold where previously the code would mostly work, but you had to pay very close attention to it. And suddenly we went from that to... almost all of the time it does what you told it to do, which makes all of the difference in the world.
  
  Now you can spin up a coding agent and say, build me a Mac application that does this thing, and you'll get something back which won't just be a buggy pile of rubbish that doesn't do anything.
  
  Software engineers as bellwethers for other information workers
  
  5:49 - I can churn out 10,000 lines of code in a day. And most of it works. Is that good? Like, how do we get from most of it works to all of it works? There are so many new questions that we're facing, which I think makes us a bellwether for other information workers.
  
  Code is easier than almost every other problem that you pose these agents because code is obviously right or wrong - either it works or it doesn't work. There might be a few subtle hidden bugs, but generally you can tell if the thing actually works.
  
  If it writes you an essay, if it prepares a lawsuit for you, it's so much harder to derive if it's actually done a good job, and to figure out if it got things right or wrong. But it's happening to us as software engineers. It came for us first.
  
  And we're figuring out, OK, what do our careers look like? How do we work as teams when part of what we did that used to take most of the time doesn't take most of the time anymore? What does that look like? And it's going to be very interesting seeing how this rolls out to other information work in the future.
  
  Lawyers are falling for this really badly. The AI hallucination cases database is up to 1,228 cases now!
  
  Plus this bit from the cold open at the start:
  
  It used to be you'd ask ChatGPT for some code, and it would spit out some code, and you'd have to run it and test it. The coding agents take that step for you now. And an open question for me is how many other knowledge work fields are actually prone to these agent loops?
  
  Writing code on my phone
  
  8:19 - I write so much of my code on my phone. It's wild. I can get good work done walking the dog along the beach, which is delightful.
  
  I mainly use the Claude iPhone app for this, both with a regular Claude chat session (which can execute code now) or using it to control Claude Code for web.
  
  Responsible vibe coding
  
  9:55 If you're vibe coding something for yourself, where the only person who gets hurt if it has bugs is you, go wild. That's completely fine. The moment you ship your vibe coding code for other people to use, where your bugs might actually harm somebody else, that's when you need to take a step back.
  
  See also When is it OK to vibe code?
  
  Dark Factories and StrongDM
  
  12:49 The reason it's called the dark factory is there's this idea in factory automation that if your factory is so automated that you don't need any people there, you can turn the lights off. Like the machines can operate in complete darkness if you don't need people on the factory floor. What does that look like for software? [...]
  
  So there's this policy that nobody writes any code: you cannot type code into a computer. And honestly, six months ago, I thought that was crazy. And today, probably 95% of the code that I produce, I didn't type myself. That world is practical already because the latest models are good enough that you can tell them to rename that variable and refactor and add this line there... and they'll just do it - it's faster than you typing on the keyboard yourself.
  
  The next rule though, is nobody reads the code. And this is the thing which StrongDM started doing last year.
  
  I wrote a lot more about StrongDM's dark factory explorations back in February.
  
  The bottleneck has moved to testing
  
  21:27 - It used to be, you'd come up with a spec and you hand it to your engineering team. And three weeks later, if you're lucky, they'd come back with an implementation. And now that maybe takes three hours, depending on how well the coding agents are established for that kind of thing. So now what, right? Now, where else are the bottlenecks?
  
  Anyone who's done any product work knows that your initial ideas are always wrong. What matters is proving them, and testing them.
  
  We can test things so much faster now because we can build workable prototypes so much quicker. So there's an interesting thing I've been doing in my own work where any feature that I want to design, I'll often prototype three different ways it could work because that takes very little time.
  
  I've always loved prototyping things, and prototyping is even more valuable now.
  
  22:40 - A UI prototype is free now. ChatGPT and Claude will just build you a very convincing UI for anything that you describe. And that's how you should be working. I think anyone who's doing product design and isn't vibe coding little prototypes is missing out on the most powerful boost that we get in that step.
  
  But then what do you do? Given your three options that you have instead of one option, how do you prove to yourself which one of those is the best? I don't have a confident answer to that. I expect this is where the good old fashioned usability testing comes in.
  
  More on prototyping later on:
  
  46:35 - Throughout my entire career, my superpower has been prototyping. I've been very quick at knocking out working prototypes of things. I'm the person who can show up at a meeting and say, look, here's how it could work. And that was kind of my unique selling point. And that's gone. Anyone can do what I could do.
  
  This stuff is exhausting
  
  26:25 - I'm finding that using coding agents well is taking every inch of my 25 years of experience as a software engineer, and it is mentally exhausting. I can fire up four agents in parallel and have them work on four different problems. And by like 11 AM, I am wiped out for the day. [...]
  
  There's a personal skill we have to learn in finding our new limits - what's a responsible way for us not to burn out.
  
  I've talked to a lot of people who are losing sleep because they're like, my coding agents could be doing work for me. I'm just going to stay up an extra half hour and set off a bunch of extra things... and then waking up at four in the morning. That's obviously unsustainable. [...]
  
  There's an element of sort of gambling and addiction to how we're using some of these tools.
  
  Interruptions cost a lot less now
  
  45:16 - People talk about how important it is not to interrupt your coders. Your coders need to have solid two to four hour blocks of uninterrupted work so they can spin up their mental model and churn out the code. That's changed completely. My programming work, I need two minutes every now and then to prompt my agent about what to do next. And then I can do the other stuff and I can go back. I'm much more interruptible than I used to be.
  
  My ability to estimate software is broken
  
  28:19 - I've got 25 years of experience in how long it takes to build something. And that's all completely gone - it doesn't work anymore because I can look at a problem and say that this is going to take two weeks, so it's not worth it. And now it's like... maybe it's going to take 20 minutes because the reason it would have taken two weeks was all of the sort of crufty coding things that the AI is now covering for us.
  
  I constantly throw tasks at AI that I don't think it'll be able to do because every now and then it does it. And when it doesn't do it, you learn, right? But when it does do something, especially something that the previous models couldn't do, that's actually cutting edge AI research.
  
  And a related anecdote:
  
  36:56 - A lot of my friends have been talking about how they have this backlog of side projects, right? For the last 10, 15 years, they've got projects they never quite finished. And some of them are like, well, I've done them all now. Last couple of months, I just went through and every evening I'm like, let's take that project and finish it. And they almost feel a sort of sense of loss at the end where they're like, well, okay, my backlog's gone. Now what am I going to build?
  
  It's tough for people in the middle
  
  29:29 - So ThoughtWorks, the big IT consultancy, did an offsite about a month ago, and they got a whole bunch of engineering VPs in from different companies to talk about this stuff. And one of the interesting theories they came up with is they think this stuff is really good for experienced engineers, like it amplifies their skills. It's really good for new engineers because it solves so many of those onboarding problems. The problem is the people in the middle. If you're mid-career, if you haven't made it to sort of super senior engineer yet, but you're not sort of new either, that's the group which is probably in the most trouble right now.
  
  I mentioned Cloudflare hiring 1,000 interns, and Shopify too.
  
  Lenny asked for my advice for people stuck in that middle:
  
  31:21 - That's a big responsibility you're putting on me there! I think the way forward is to lean into this stuff and figure out how do I help this make me better?
  
  A lot of people worry about skill atrophy: if the AI is doing it for you, you're not learning anything. I think if you're worried about that, you push back at it. You have to be mindful about how you're applying the technology and think, okay, I've been given this thing that can answer any question and often gets it right. How can I use this to amplify my own skills, to learn new things, to take on much more ambitious projects? [...]
  
  33:05 - Everything is changing so fast right now. The only universal skill is being able to roll with the changes. That's the thing that we all need.
  
  The term that comes up most in these conversations about how you can be great with AI is agency. I think agents have no agency at all. I would argue that the one thing AI can never have is agency because it doesn't have human motivations.
  
  So I'd say that's the thing is to invest in your own agency and invest in how to use this technology to get better at what you do and to do new things.
  
  It's harder to evaluate software
  
  The fact that it's so easy to create software with detailed documentation and robust tests means it's harder to figure out what's a credible project.
  
  37:47 Sometimes I'll have an idea for a piece of software, Python library or whatever, and I can knock it out in like an hour and get to a point where it's got documentation and tests and all of those things, and it looks like the kind of software that previously I'd have spent several weeks on - and I can stick it up on GitHub
  
  And yet... I don't believe in it. And the reason I don't believe in it is that I got to rush through all of those things... I think the quality is probably good, but I haven't spent enough time with it to feel confident in that quality. Most importantly, I haven't used it yet.
  
  It turns out when I'm using somebody else's software, the thing I care most about is I want them to have used it for months.
  
  I've got some very cool software that I built that I've never used. It was quicker to build it than to actually try and use it!
  
  The misconception that AI tools are easy
  
  41:31 - Everyone's like, oh, it must be easy. It's just a chat bot. It's not easy. That's one of the great misconceptions in AI is that using these tools effectively is easy. It takes a lot of practice and it takes a lot of trying things that didn't work and trying things that did work.
  
  Coding agents are useful for security research now
  
  19:04 - In the past sort of three to six months, they've started being credible as security researchers, which is sending shockwaves through the security research industry.
  
  See Thomas Ptacek: Vulnerability Research Is Cooked.
  
  At the same time, open source projects are being bombarded with junk security reports:
  
  20:05 - There are these people who don't know what they're doing, who are asking ChatGPT to find a security hole and then reporting it to the maintainer. And the report looks good. ChatGPT can produce a very well formatted report of a vulnerability. It's a total waste of time. It's not actually verified as being a real problem.
  
  A good example of the right way to do this is Anthropic's collaboration with Firefox, where Anthropic's security team verified every security problem before passing them to Mozilla.
  
  OpenClaw
  
  Of course we had to talk about OpenClaw! Lenny had his running on a Mac Mini.
  
  1:29:23 - OpenClaw demonstrates that people want a personal digital assistant so much that they are willing to not just overlook the security side of things, but also getting the thing running is not easy. You've got to create API keys and tokens and install stuff. It's not trivial to get set up and hundreds of thousands of people got it set up. [...]
  
  The first line of code for OpenClaw was written on November the 25th. And then in the Super Bowl, there was an ad for AI.com, which was effectively a vaporware white labeled OpenClaw hosting provider. So we went from first line of code in November to Super Bowl ad in what? Three and a half months.
  
  I continue to love Drew Breunig's description of OpenClaw as a digital pet:
  
  A friend of mine said that OpenClaw is basically a Tamagotchi. It's a digital pet and you buy the Mac Mini as an aquarium.
  
  Journalists are good at dealing with unreliable sources
  
  In talking about my explorations of AI for data journalism through Datasette:
  
  1:34:58 - You would have thought that AI is a very bad fit for journalism where the whole idea is to find the truth. But the flip side is journalists deal with untrustworthy sources all the time. The art of journalism is you talk to a bunch of people and some of them lie to you and you figure out what's true. So as long as the journalist treats the AI as yet another unreliable source, they're actually better equipped to work with AI than most other professions are.
  
  The pelican benchmark
  
  Obviously we talked about pelicans riding bicycles:
  
  56:10 - There appears to be a very strong correlation between how good their drawing of a pelican riding a bicycle is and how good they are at everything else. And nobody can explain to me why that is. [...]
  
  People kept on asking me, what if labs cheat on the benchmark? And my answer has always been, really, all I want from life is a really good picture of a pelican riding a bicycle. And if I can trick every AI lab in the world into cheating on benchmarks to get it, then that just achieves my goal.
  
  59:56 - I think something people often miss is that this space is inherently funny. The fact that we have these incredibly expensive, power hungry, supposedly the most advanced computers of all time. And if you ask them to draw a pelican on a bicycle, it looks like a five-year-old drew it. That's really funny to me.
  
  And finally, some good news about parrots
  
  Lenny asked if I had anything else I wanted to leave listeners with to wrap up the show, so I went with the best piece of news in the world right now.
  
  1:38:10 - There is a rare parrot in New Zealand called the Kākāpō. There are only 250 of these parrots left in the world. They are flightless nocturnal parrots - beautiful green dumpy looking things. And the good news is they're having a fantastic breeding season in 2026,
  
  They only breed when the Rimu trees in New Zealand have a mass fruiting season, and the Rimu trees haven't done that since 2022 - so there has not been a single baby kākāpō born in four years.
  
  This year, the Rimu trees are in fruit. The kākāpō are breeding. There have been dozens of new chicks born. It's a really, really good time. It's great news for rare New Zealand parrots and you should look them up because they're delightful.
  
  Everyone should watch the live stream of Rakiura on her nest with two chicks!
  
  YouTube chapters
  
  Here's the full list of chapters Lenny's team defined for the YouTube video:
  - 00:00: Introduction to Simon Willison
  - 02:40: The November 2025 inflection point
  - 08:01: What's possible now with AI coding
  - 10:42: Vibe coding vs. agentic engineering
  - 13:57: The dark-factory pattern
  - 20:41: Where bottlenecks have shifted
  - 23:36: Where human brains will continue to be valuable
  - 25:32: Defending of software engineers
  - 29:12: Why experienced engineers get better results
  - 30:48: Advice for avoiding the permanent underclass
  - 33:52: Leaning into AI to amplify your skills
  - 35:12: Why Simon says he's working harder than ever
  - 37:23: The market for pre-2022 human-written code
  - 40:01: Prediction: 50% of engineers writing 95% AI code by the end of 2026
  - 44:34: The impact of cheap code
  - 48:27: Simon's AI stack
  - 54:08: Using AI for research
  - 55:12: The pelican-riding-a-bicycle benchmark
  - 59:01: The inherent ridiculousness of AI
  - 1:00:52: Hoarding things you know how to do
  - 1:08:21: Red/green TDD pattern for better AI code
  - 1:14:43: Starting projects with good templates
  - 1:16:31: The lethal trifecta and prompt injection
  - 1:21:53: Why 97% effectiveness is a failing grade
  - 1:25:19: The normalization of deviance
  - 1:28:32: OpenClaw: the security nightmare everyone is looking past
  - 1:34:22: What's next for Simon
  - 1:36:47: Zero-deliverable consulting
  - 1:38:05: Good news about Kakapo parrots
  You are only seeing the long-form articles from my blog. Subscribe to /atom/everything/ to get all of my posts, or take a look at my other subscription options.
6. 🔗 Evan Schwartz A Rave Review of Superpowers (for Claude Code) rss
  
  I have no connection to the authors of the Superpowers plugin for Claude Code, but I have been raving about it to everyone I talk to. Using Claude Code with Superpowers is so much more productive and the features it builds are so much more correct than with stock Claude Code. I cannot recommend it enough.
  
  Earlier, my main issue with Claude Code (and other models + harnesses I’ve tried) was that it was sometimes too quick to jump to implementing a solution that might be right, or might be totally off.
  
  Plan mode helped a bit. However, in Plan mode, Claude would write up a giant plan document and ask for feedback. It's hard to review a multi-page plan. Making matters worse, if you give it feedback, it would respond with a whole new version of the multi-page plan. That's not a productive way to plan out a project or feature.
  
  Superpowers fixes both of these issues, and more. I'll lay out the workflow, as I understand it, and why I appreciate its structure but you can also stop reading here and just go try it.
  
  Superpowers’ high-level flow is: Brainstorming → Reviewing Options and Tradeoffs → Plan Sketch → Design Doc → Implementation Plan → Implementation Steps.
  
  Brainstorming
  
  Superpowers almost always starts off in brainstorm mode. It explores your codebase, asks you plenty of questions, and comes up with some general directions you could go in.
  
  Options and Tradeoffs
  
  A key part of the brainstorming process is that, after asking questions, it will present multiple options with tradeoffs. It is extremely helpful to consider different options, see tradeoffs laid out, and choose or discuss them before getting more detailed.
  
  Recently, they also added a visual design skill that makes Claude build simple mock-ups for UI changes and other visual features. This starts a local dev server so you can review, discuss, and iterate on the mock-ups before proceeding. Great job team, keep up the great work.
  
  Plan Sketch
  
  After you've agreed on the options to pursue, Claude + Superpowers will give you back a high-level description of the plan. This could be a dozen bullet points or a slightly longer write-up. In contrast to the default Plan mode, this is a much easier format to weigh in on.
  
  Design Doc
  
  Only after agreeing on the high-level version of the plan, Claude + Superpowers will write up a full design doc. This is most similar to the kind of plan Claude Code would write without Superpowers. But at this point, you've already agreed on the high-level direction, which makes it much easier to review and comment on the plan. If you have comments, they are probably going to be a bit more detailed, rather than "rewrite this whole thing and go in a different direction".
  
  Also, Superpowers’ plan document is a markdown file in your repository that you can read, comment on, and edit in your own editor. One friend said that being able to edit the plan on his own terms felt way more empowering than Claude Code’s normal UX for reviewing plans.
  
  Implementation Plan and Implementation
  
  After you approve the design doc, Claude + Superpowers will write up an implementation plan and review that plan against the design doc. Once you approve that, it can launch subagents to implement each part of the plan, and it automatically reviews their work against the implementation plan.
  
  Thanks
  
  Thanks to Jesse Vincent for making this plugin! It has made my use of Claude Code so much more productive. I feel better about tradeoffs being made and much more confident that the code written does what I want.
  
  I'll be eagerly installing each Superpowers update and keeping an eye on what else Jesse's company Prime Radiant puts out (you can also add their blog to your Scour feed 😉).
  
  Superpowers for Other Domains?
  
  I have friends who are academic researchers. Every time they tell me about issues they've run into trying to use Claude or other AI tools, I've immediately thought that they could use an equivalent structured workflow plugin that adapts a Superpowers-style workflow to non-programming domains. Just a thought for the Prime Radiant folks or others who are building agent-focused dev tools.
  
  Thanks also to Alex Kesling and Eliot Hederman for comments on a draft of this blog post.
  
  Discuss on Hacker News, Lobsters, Bluesky, or r/ClaudeAI.
7. 🔗 r/reverseengineering How to build .NET obfuscator - Part I rss
  
  submitted by /u/kant2002
  [link] [comments]
8. 🔗 @binaryninja@infosec.exchange T-10 minutes until the bots battle to find different bug classes, break mastodon
  
  T-10 minutes until the bots battle to find different bug classes, break keygens, decrypt strings, extract private keys, analyze malware, and win some games!
  
  We'll be pitting agent vs agent, assistant vs assistant, using both local and remote models to see who comes out on top.
  
  Featuring our multi-time guest, Tim Blazytko, this is one you won't want to miss! https://www.youtube.com/watch?v=TBqBpaqecMA
9. 🔗 r/wiesbaden ADHS vor Jahren diagnostiziert, Arzt in Rente – muss ich alles neu machen rss
  
  Ich wurde mit 17 von einem Jugendpsychiater mit ADHS diagnostiziert und habe anschließend etwa zwei Jahre Medikinet eingenommen. Die Behandlung habe ich damals wegen Nebenwirkungen (habe mich deprimiert und leer gefühlt, das übliche) abgebrochen.
  
  Ein paar Jahre später habe ich nun ein neues Studium begonnen, bin ausgezogen und merke, dass mich der Alltag zunehmend überfordert. Deshalb würde ich gerne erneut eine medikamentöse Behandlung versuchen, diesmal mit Elvanse.
  
  Das Problem ist, dass der Arzt von damals inzwischen im Ruhestand ist und die Praxis nicht mehr existiert. Ich habe auch keine Unterlagen meiner Diagnose, nur noch ein älteres Schreiben, in dem ein Behandlungsplan vom Arzt mit Methylphenidat erwähnt wird.
  
  Ich bin mir aktuell unsicher, wie ich am besten vorgehen soll. Weiß jemand, ob man frühere Diagnosen irgendwie über die Krankenkasse einsehen kann oder ob es eine Art zentrale Krankenakte gibt?
  
  Ungern möchte ich den gesamten Diagnoseprozess noch einmal komplett durchlaufen und hoffe, möglichst zeitnah wieder eine Behandlung zu bekommen. Es ist ja ohnehin schon schwierig, Termine zu bekommen.
  
  Ich wäre sehr dankbar für Tipps:
  
  - Wie ich am besten vorgehen sollte
  
  - Wie ich das unkompliziert Ärzten für einen Termin erkläre
  
  - Ob ich zwingend zu einem Erwachsenenpsychiater gehen muss oder ob auch andere Ärzte infrage kommen
  
  - Und ob jemand Anlaufstellen im Raum Wiesbaden, Mainz oder Frankfurt (und Umgebung) empfehlen kann
  
  Vielen Dank!
  
  submitted by /u/renjunniee
  [link] [comments]
10. 🔗 r/LocalLLaMA Gemma 4 and Qwen3.5 on shared benchmarks rss
  
  | submitted by /u/fulgencio_batista
  [link] [comments]
  ---|---
11. 🔗 r/york York man told fitting safety rail on stairs would be 'unfair' rss
  
  | submitted by /u/Kagedeah
  [link] [comments]
  ---|---
12. 🔗 r/Leeds Yorkshire Buses Update: rss
  
  Starting from Tuesday (07/04/2026, the following services will be taken over:
  
  - 212 by Go-Ahead West Yorkshire
  
  - 116 by First Group
  
  - 61 by Connexions Buses
  
  - 30 by Lethers Travel
  
  All of these are short-term emergency contracts until the next official service change date in July, at which point they will be retendered as part of the normal annual process.
  
  submitted by /u/CaptainYorkie1
  [link] [comments]
13. 🔗 r/Yorkshire “Solitude” - Red Squirrel, Yorkshire Dales National Park rss
  
  | submitted by /u/aspiranthighlander
  [link] [comments]
  ---|---
14. 🔗 r/wiesbaden Kunstgruppe oder offene Ateliers? rss
  
  Hi zusammen,
  
  weiß einer von euch zufällig, ob es in Wiesbaden eine offene Kunstgruppe oder einen offenen Atelier gibt?
  
  Möchte Gleichgesinnte kennenlernen und vielleicht sogar gemeinsam etwas malen :)
  
  submitted by /u/CalmSorry
  [link] [comments]
15. 🔗 r/LocalLLaMA Gemma 4 has been released rss
  | https://huggingface.co/unsloth/gemma-4-26B-A4B-it-GGUF https://huggingface.co/unsloth/gemma-4-31B-it-GGUF https://huggingface.co/unsloth/gemma-4-E4B-it-GGUF https://huggingface.co/unsloth/gemma-4-E2B-it-GGUF https://huggingface.co/collections/google/gemma-4 What’s new in Gemma 4 https://www.youtube.com/watch?v=jZVBoFOJK-Q 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 small models) 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 four distinct sizes: E2B , E4B , 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 and E4B 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.
  Models Overview
  
  Gemma 4 models are designed to deliver frontier-level performance at each size, targeting deployment scenarios from mobile and edge devices (E2B, E4B) to consumer GPUs and workstations (26B A4B, 31B). They are well-suited for reasoning, agentic workflows, coding, and multimodal understanding. The models employ a hybrid attention mechanism that interleaves local sliding window attention with full global attention, ensuring the final layer is always global. This hybrid design delivers the processing speed and low memory footprint of a lightweight model without sacrificing the deep awareness required for complex, long-context tasks. To optimize memory for long contexts, global layers feature unified Keys and Values, and apply Proportional RoPE (p-RoPE). Core Capabilities Gemma 4 models handle a broad range of tasks across text, vision, and audio. Key capabilities include:
  - Thinking – Built-in reasoning mode that lets the model think step-by-step before answering.
  - Long Context – Context windows of up to 128K tokens (E2B/E4B) and 256K tokens (26B A4B/31B).
  - Image Understanding – Object detection, Document/PDF parsing, screen and UI understanding, chart comprehension, OCR (including multilingual), handwriting recognition, and pointing. Images can be processed at variable aspect ratios and resolutions.
  - Video Understanding – Analyze video by processing sequences of frames.
  - Interleaved Multimodal Input – Freely mix text and images in any order within a single prompt.
  - Function Calling – Native support for structured tool use, enabling agentic workflows.
  - Coding – Code generation, completion, and correction.
  - Multilingual – Out-of-the-box support for 35+ languages, pre-trained on 140+ languages.
  - Audio (E2B and E4B only) – Automatic speech recognition (ASR) and speech-to-translated-text translation across multiple languages.
  https://preview.redd.it/3dbm6nhrvssg1.png?width=1282&format=png&auto=webp&s=8625d113e9baa3fab79a780fd074a5b36e4d6f0c https://preview.redd.it/mtzly5myxssg1.png?width=1200&format=png&auto=webp&s=5c95a73ff626ebeafd3645d2e00697c793fa0b16 submitted by /u/jacek2023
  [link] [comments]
  ---|---
16. 🔗 r/Leeds Cherry Blossom in Leeds rss
  
  Is there any where in Leeds that is scenic for its cherry blossom at this time of year? I'm planning on visiting The Stray in Harrogate, is there anywhere thats simular?
  
  submitted by /u/AshCucumber
  [link] [comments]
17. 🔗 r/Harrogate Cherry Blossom rss
  
  Hi, I'd like to know when the cherry blossom is visible along The Stray and other places in Harrogate. I'm planning on coming during the weekday to make a day trip.
  
  submitted by /u/AshCucumber
  [link] [comments]
18. 🔗 r/reverseengineering Tried to buy a pint, Finding a Trojan: My First Malware Analysis rss
  
  submitted by /u/im_the_tea_drinker_
  [link] [comments]
19. 🔗 r/york York to Whitby and Scarborough rss
  
  Hi, I'm planning a trip on a Sunday from York to Whitby and possibly Scarborough. The Coastliner runs from York to Whitby, and I've heard that the view is worth it, even though it takes two hours and starts later on Sundays. However, it takes another hour by bus to reach Scarborough from there. In Scarborough, I can take the train to York instead of the Coastliner, but that's an extra 50 minutes. Is it all worth it in one day? Or should I just focus on Whitby or Scarborough?
  
  submitted by /u/Adventurous-Drop-241
  [link] [comments]
20. 🔗 r/york York Hackspace open afternoon, Easter Saturday 4th April rss
  
  | York Hackspace is a makerspace in Layerthorpe (just near Red Goat) and we'll be having an open afternoon this Saturday 4th April (2pm-6pm, but message me if you'd like to turn up earlier or later) for anybody who'd like to see around the hackspace but can't make our regular Wednesday open evenings. Hackspaces/makerspaces are essentially workshops where members get 24/7 access to all of the tools and equipment (wood/metalworking workshop and tools, 3D printers, laser cutters, art/craft/sewing facilities, full electronics workbenches etc), basically everything you'd need to turn an idea into reality. Non-members are also welcome to make use of many of our facilities on open afternoons/evenings, more details at https://york.hackspace.org.uk/wiki/Weekly_Open_Evening . If you've got some time to spare and wanted to see the hackspace and our facilities, why not come along? We'd love to show you around! Details of how to find us are on https://york.hackspace.org.uk/wiki/10_Redeness_Street - please use the intercom doorbell to get in. We also have a Discord, which a lot of local maker types hang out and you're welcome to join - https://york.hackspace.org.uk/wiki/Discord submitted by /u/gavinatkinson
  [link] [comments]
  ---|---
21. 🔗 sacha chua :: living an awesome life Extract PDF highlights into an Org file with Python rss
  I've been trying to find a good workflow for highlighting interesting parts of PDFs, and then getting that into my notes as images and text in Emacs. I think I've finally figured out something that works well for me that feels natural (marking things.
  
  I wanted to read through Prot's Emacs configuration while the kiddo played with her friends at the playground. I saved the web page as a PDF and exported it to Noteful. The PDF has 481 pages. Lots to explore! It was a bit chilly, so I had my gloves on. I used a capacitative stylus in my left hand to scroll the document and an Apple Pencil in my right hand to highlight the parts I wanted to add to my config or explore further.
  
  Back at my computer, I used pip install pymupdf to install the PyMuPDF library. I poked around the PDF in the Python shell to see what it had, and I noticed that the highlights were drawings with fill 0.5. So I wrote this Python script to extract the images and text near that rectangle:
  import fitz import pathlib import sys import os BUFFER = 5 def extract_highlights(filename, output_dir): doc = fitz.open(filename) s = "* Excerpts\n" for page_num, page in enumerate(doc): page_width = page.rect.width page_text = "" for draw_num, d in enumerate(page.get_drawings()): if d['fill_opacity'] == 0.5: rect = d['rect'] clip_rect = fitz.Rect(0, rect.y0 - BUFFER, page_width, rect.y1 + BUFFER) img = page.get_pixmap(clip=clip_rect) img_filename = "page-%03d-%d.png" % (page_num + 1, draw_num + 1) img.save(os.path.join(output_dir, img_filename)) text = page.get_text(clip=clip_rect) page_text = (page_text + "[[file:%s]]\n#+begin_quote\n[[pdf:%s::%d][p%d]]: %s\n#+end_quote\n\n" % (img_filename, os.path.join("..", filename), page_num + 1, page_num + 1, text)) if page_text != "": s += "** Page %d\n%s" % (page_num + 1, page_text) pathlib.Path(os.path.join(output_dir, "index.org")).write_bytes(s.encode()) if __name__ == '__main__': if len(sys.argv) < 3: print("Usage: list-highlights.py pdf-filename output-dir") else: extract_highlights(sys.argv[1], sys.argv[2])
  After I opened the resulting index.org file, I used C-u C-u C-c C-x C-v (org-link-preview) to make the images appear inline throughout the whole buffer. There's a little extra text from the PDF extraction, but it's a great starting point for cleaning up or copying. The org-pdftools package lets me link to specific pages in PDFs, neat!
  
  Figure 1: Screenshot of Org Mode file with link previews
  
  To set up org-pdftools, I used:
  (use-package org-pdftools :hook (org-mode . org-pdftools-setup-link))
  Here's my quick livestream about the script with a slightly older version that had an off-by-one bug in the page numbers and didn't have the fancy PDF links. =)
  
  nilWatch on YouTube
  
  View Org source for this post
  
  You can e-mail me at sacha@sachachua.com.
22. 🔗 r/Yorkshire A beautiful morning for perambulating along the Swale (Richmond, Yorks) rss
  
  | submitted by /u/Still_Function_5428
  [link] [comments]
  ---|---
23. 🔗 r/york Anyone changing driving habits in York due to fuel increases and shortages? rss
  
  I’m seeing a lot of people on York groups (Facebook mainly) fretting about where fuel is available locally. With Easter weekend coming up and roads usually being full of people traveling to the many nice spots around York (we are lucky to have lots of English Heritage sites on our doorstep and places like Whitby / Scarborough / Filey not far away)… I’m wondering will there be any noticeable changes in behaviour? Just not sure if I’m seeing some people needlessly panicking or if the nervousness is real that might mean more of us spend less time on the roads this Easter weekend?
  
  Just came to mind as I have a few days off and wondering where to go!
  
  submitted by /u/alusalas
  [link] [comments]
24. 🔗 r/Yorkshire Scarborough Sunset rss
  
  | submitted by /u/ioscommenter
  [link] [comments]
  ---|---
25. 🔗 r/Leeds Angine De Poitrine 2nd Date rss
  
  2nd date at project house sold out in seconds.
  
  I have 3 devices trying to get tickets, all three refreshed once and they were gone. Wild.
  
  submitted by /u/Phil-pot
  [link] [comments]
26. 🔗 r/LocalLLaMA Can we block fresh accounts from posting? rss
  
  Flood of useless vibe coded projects is getting out of hand...
  
  submitted by /u/king_of_jupyter
  [link] [comments]
27. 🔗 r/Yorkshire Where is your summer spot in nature rss
  
  | I adore the buttercups in Muker, when the meadows in the Yorkshire Dales come alive. It's so quiet there, and feeling the sun on my skin (when the planets align lmaoo), the sound of insects, the smell of grass, and seeing the old stone barns take my anxiety away for a short moment. What is yours? Photo credit: Andy Beck submitted by /u/askepticalbureaucrat
  [link] [comments]
  ---|---
28. 🔗 r/york York Photos rss
  
  | what a lovely day submitted by /u/Queasy-Plan-1868
  [link] [comments]
  ---|---
29. 🔗 jj-vcs/jj v0.40.0 release
  About
  
  jj is a Git-compatible version control system that is both simple and powerful. See
  the installation instructions to get started.
  
  Release highlights
  
  None
  
  Breaking changes
  
  None
  
  Deprecations
  
  None
  
  New features
  - New diff_lines_added() and diff_lines_removed() revset functions for
    matching content on only one side of a diff.
  - The end parameter in the String.substr(start, end) templating method is
    now optional. If not given, substr() returns from start to the end of the
    string.
  - WorkspaceRef templates now provide a .root() method to show the absolute
    path to each workspace root.
  - The jj arrange TUI now includes immediate parents and children. They are not
    selectable and are dimmed by default.
  - jj arrange uses the default log template (builtin_log_compact) instead of
    the shorter commit summary style.
  - In the jj arrange TUI, the "swap up/down" actions now move along graph edges
    even if the commit rows are not adjacent.
  - Diff colors can now be configured
    differently for each format.
  - jj op log now includes the name of the workspace the operation was created
    from.
  - The config() template function now accepts a Stringify expression instead
    of LiteralString. This allows looking up configuration values dynamically.
  - jj op show, jj op diff, jj op log -p now only show "interesting"
    revisions by default (defined by revsets.op-diff-changes-in). A new flag,
    --show-changes-in, can be used to override this. #6083
  Fixed bugs
  - .gitignore with UTF-8 BOM can now be parsed correctly.
  - Fix incompatibility with gpgsm 2.5.x.
  Contributors
  
  Thanks to the people who made this release happen!
  - Aaron Sutton (@aaronjsutton)
  - Adam Sandberg Eriksson (@adamse)
  - Anton Älgmyr (@algmyr)
  - Austin Seipp (@thoughtpolice)
  - Benjamin Tan (@bnjmnt4n)
  - Ben Warren (@warrenbhw)
  - Bryant Chandler (@brychanrobot)
  - David Higgs (@higgsd)
  - Filip Weiss (@fiws)
  - Gabriel Goller (@kaffarell)
  - Gaëtan Lehmann (@glehmann)
  - Ilya Grigoriev (@ilyagr)
  - Jeff Turner (@jefft)
  - Joseph Lou (@josephlou5)
  - Josh Steadmon (@steadmon)
  - KITAGAWA Yasutaka (@kit494way)
  - Liam (@terror)
  - Li-Wen Hsu (@lwhsu)
  - Martin von Zweigbergk (@martinvonz)
  - Philip Metzger (@PhilipMetzger)
  - Poliorcetics (@poliorcetics)
  - Remo Senekowitsch (@senekor)
  - Rob Pilling (@bobrippling)
  - Scott Taylor (@scott2000)
  - Shnatu
  - Stephen Prater (@stephenprater)
  - Yuya Nishihara (@yuja)
  - Zeyi Fan (@fanzeyi)
30. 🔗 r/LocalLLaMA Qwen3.6-Plus rss
  
  | Blog post: https://qwen.ai/blog?id=qwen3.6 From Chujie Zheng on 𝕏: https://x.com/ChujieZheng/status/2039560126047359394 submitted by /u/Nunki08
  [link] [comments]
  ---|---
31. 🔗 doomemacs/doomemacs v2.1.0 release
  
  v2.1.0
32. 🔗 HexRaysSA/plugin-repository commits sync repo: +1 release rss
```
sync repo: +1 release

## New releases
- [capa](https://github.com/mandiant/capa): 9.4.0
```
33. 🔗 Console.dev newsletter Semiotic rss
  
  Description: Streaming-first data visualization.
  
  What we like: Push streaming data at 60fps or just pass an array of static data. Simple React library that gives you full access to the underlying components if the built-in ones aren’t sufficient. Supports a range of charts and frames. Customizable with themes. Also supports server-side rendering.
  
  What we dislike: If you need basic charts with minimal customization then it’s overkill - they recommend something like Recharts in that case.
34. 🔗 Console.dev newsletter nono rss
  
  Description: Runtime AI safety sandbox.
  
  What we like: Snapshots filesystem changes so you can easily roll back. Uses Kernel-level isolations on macOS, Linux, and Windows. Immutable session logs with cryptographic verification. Native SDKs for Python, TypeScript, Rust.
  
  What we dislike: You need to use C FFI bindings for other languages (great they exist of course, but better to have native SDKs where possible).
35. 🔗 exe.dev A Transparent UI Pattern rss
  
  exe.dev has one API: it's the command you would write in the exe.dev lobby. For example, share add island-anchor "philip+demo2@bold.dev" shares the HTTP server for the VM island-anchor to that e-mail address. (We believe sharing a web app should be as simple as sharing a document!) You can do that very same command over our HTTP API. Our UI tells you what command it's running, right down to the quoting.
  
  We do this for two reasons:
  
  First, it teaches our users that everything they're doing in the UI, they (and their agents!) can do in the CLI. We know our users are going to want to script.
  
  Second, it keeps us honest. The UI can't cheat. If the system doesn't expose the right API knobs, we find out immediately because the UI uses the same interface.
  
  We like this pattern. We hope you do too.
April 01, 2026
1. 🔗 IDA Plugin Updates IDA Plugin Updates on 2026-04-01 rss
  IDA Plugin Updates on 2026-04-01
  
  New Releases:
  - capa v9.4.0
  Activity:
  - AETHER
    
    d0e5f6a2: v2026.1.2: Resolve annotator concurrency lock-up
  - binsync
    
    31a89111: Auxiliary Server Enhancement to See Which Users are Working on a Func…
  - capa
    
    7a79f799: Merge pull request #2982 from mandiant/fix/workflow-zip-env
    
    4e4e1639: ci: fix ZIP_NAME environment variable in build workflow
    
    3276e351: Prepare release v9.4.0 (#2981)
  - Greffe
    
    b83852c2: Merge pull request #53 from Lixhr/52-trampolinebuilder-init-the-tramp…
    
    435dbb20: Implement Plan Trampoline based on index
    
    3d3cb816: Fix segfault on unitialized IArchStubs
    
    07e9fe19: Implement PatchLayout
    
    43dfef8f: Init shared stubs
    
    08ed8daf: Align offsets
    
    5ba2d52a: Init shared stubs
    
    b5e5c69e: Merge pull request #51 from Lixhr/cleaning_target
    
    b17e7e4d: Clean
    
    0b4de77a: refactor Target
  - IDAPluginList
    
    c722ac7e: chore: Auto update IDA plugins (Updated: 19, Cloned: 0, Failed: 0)
  - IDAQ6
    
    097ffdbf: True Promise 4
    
    f4392245: True Promise 4
2. 🔗 r/reverseengineering BurnerNet v1.0.0: A Zero-Trust C++20 HTTP Client Engine rss
  
  submitted by /u/KriXxPlay
  [link] [comments]
3. 🔗 r/LocalLLaMA The Bonsai 1-bit models are very good rss
  
  | Hey everyone, Tim from AnythingLLM and yesterday I saw the PrismML Bonsai post so i had to give it a real shot because 14x smaller models (in size and memory) would actually be a huge game changer for Local models - which is basically all I do. I personally only ran the Bonsai 8B model for my tests, which are more practical that anything (chat, document summary, tool calling, web search, etc) so your milage may vary but I was running this on an M4 Max 48GB MacBook Pro and I wasnt even using the MLX model. I do want to see if I can get this running on my old Android S20 with the 1.7B model. The only downside right now to this is you cannot just load this into llama.cpp directly even though it is a GGUF and instead need to use their fork of llama.cpp to support the operations for 1-bit. That fork is really behind llama.cpp and ggerganov just merged in the KV rotation PR today, which is single part of TurboQuant but supposedly helps with KV accuracy at compression - so I made an upstream fork with 1-bit changes (no promises it works everywhere lol). I can attest this model is not even on the same planet as the previously available MSFT BitNet models which we basically unusable and purely for research purposes. I didnt even try to get this running on CUDA but I can confirm the memory pressure is indeed much lower compared to something of a similar size (Qwen3 VL 8B Instruct Q4_K_M) - I know that is not an apples to apples but just trying to give an idea. Understandably news like this on April fools is not ideal, but its actually not a joke and we finally have a decent 1-bit model series! I am sure these are not easy to train up so maybe we will see others do it soon. TBH, you would think news like this would shake a memory or GPU stock like TurboQuant did earlier this week but yet here we are with an actual real model that runs incredibly well with less resources out in the wild and like...crickets. Anyway, lmk if y'all have tried this out yet and thoughts on it. I don't work with PrismML or even know anyone there, just thought it was cool. submitted by /u/tcarambat
  [link] [comments]
  ---|---
4. 🔗 r/Yorkshire Yorkshire Buses folds 'with heavy heart' as costs rise rss
  
  | submitted by /u/Kagedeah
  [link] [comments]
  ---|---
5. 🔗 @binaryninja@infosec.exchange Sludge?! In Binary Ninja? Happy April 1st! (Yes, the plugin is real though) mastodon
  
  Sludge?! In Binary Ninja? Happy April 1st! (Yes, the plugin is real though)
  
  https://github.com/CouleeApps/sludge_content_sidebar
  
  Now available in the plugin manager.
6. 🔗 r/Leeds Be cautious regarding Leeds job offers! rss
  
  In one day, I have recieved emails and texts from three separate companies who have claimed to be super impressed with my CV despite it being mid. All three of them put pressure on a Zoom call that apparently was in high demand, to explain what their business was all about. Joined one for a pisstake and it was just a load of waffle and no actual info. Searched the companies and there is no trace of them on Google results, maps or Linked In. The companies were Blue Horizon, SBS (?), and Pentagon.
  
  Basically just be careful and don't give them the time of day.
  
  submitted by /u/No-Character-3961
  [link] [comments]
7. 🔗 r/york Little years Acomb nursery reviews rss
  
  TLDR looking for reviews/experiences of little years nursery in Acomb
  
  Hello, apologies I know there have been a few nursery threads but they’re all quite old. We’ve got a place at little years Acomb for our baby to start in September when she’ll be 12 months. Looked around last year when I was pregnant and thought it seemed nice but now I am actually a mum I feel far more concerned/fussy about sending her to the right place, so would love to hear any experiences people have had
  
  Thanks!
  
  submitted by /u/DietUsed6570
  [link] [comments]
8. 🔗 r/Yorkshire Spring has sprung (at Nostell) rss
  
  | submitted by /u/ioscommenter
  [link] [comments]
  ---|---
9. 🔗 r/Yorkshire I filmed a WW1 memorial site at night in Barnsley. rss
  
  Check out my video ORAVINE
  
  This hidden gem is a open-air chapel at Silverwood Scout Camp, built to remember local Barnsley pals that sadly lost their lives in WW1.
  
  Does anyone have any stories about this particular memorial or know of any other sites similar in Yorkshire?
  
  submitted by /u/9arke1
  [link] [comments]
10. 🔗 r/Yorkshire York to Whitby rss
  
  submitted by /u/silvergal81
  [link] [comments]
11. 🔗 r/york Birthday recommendations! rss
  
  Hi everyone!
  
  I am treating a friend to a day out in York for her birthday. I'm looking for an experience/activity, then a wine/cheese based late lunch, and then any pubs/venues that have live music or maybe regular (decent) comedy. Also your best pub gardens as it's in May and I am hoping for an outside beer or two!
  
  For an experience/activity I'm pondering the gin making at the York Distillery - anyone done this? It seems to get great reviews but I want to make sure it is worth the money! Also have seen Paint & Sip events at Plonkers - anyone been to one of these and can tell me how it was?
  
  Anything else fun and unusual? Other things I've found on Googling are the usual Jorvik or York Dungeon but we've both done those before :)
  
  Wine and cheese I am looking at 22 Yards or Howl - thoughts? Anywhere else?
  
  Thank you in advance!
  
  ETA it will be a Saturday, and also for activities, things like bingo brunch or drag shows would also work!
  
  submitted by /u/Previous-Weird9577
  [link] [comments]
12. 🔗 r/york Extra commuter trains announced for York-Scarborough rail route rss
  
  | submitted by /u/Due_Ad_3200
  [link] [comments]
  ---|---
13. 🔗 r/Harrogate Is visiting this weekend worth it? rss
  
  Heya! Is visiting harro worth it this week? Weekdays or Saturday’s better? Is it getting greener by now?
  
  Spots to try and check out will be much appreciated too!
  
  submitted by /u/jo_bidenn
  [link] [comments]
14. 🔗 r/LocalLLaMA TurboQuant isn’t just for KV: Qwen3.5-27B at near-Q4_0 quality, about 10% smaller, and finally fitting on my 16GB 5060 Ti rss
  | I bought an RTX 5060 Ti 16GB around Christmas and had one goal: get a strong model running locally on my card without paying api fees. I have been testing local ai with open claw. I did not come into this with a quantization background. I only learned about llama, lmstudio and ollama two months ago. I just wanted something better than the usual Q3-class compromise (see my first post for benchmark). Many times, I like to buy 24gb card but looking at the price, I quickly turned away. When the TurboQuant paper came out, and when some shows memory can be saved in KV, I started wondering whether the same style of idea could help on weights , not just KV/ cache.
  P/S. I was nearly got the KV done with cuda support but someone beat me on it. After many long nights (until 2am) after work, that turned into a llama.cpp fork with a 3.5-bit weight format I’m calling TQ3_1S:
  - Walsh-Hadamard rotation
  - 8-centroid quantization
  - dual half-block scales
  - CUDA runtime support in llama.cpp
  This work is inspired by the broader transform-based quantization line, especially RaBitQ-style Walsh-Hadamard rotation ideas and the recent TurboQuant result (Tom). The thing I wanted to test was whether that same geometry could help on weights, not just KV/cache.
  
  Main Result on Qwen3.5-27B
  - Q4_0: 7.2431 +/- 0.04822
  - TQ3_1S: 7.2570 +/- 0.04802
  That is a gap of only +0.0139 PPL, about 0.19%, on the full wiki.test.raw pass (580 chunks, c=512).
  
  Size
  - Q4_0: about 14.4 GB
  - TQ3_1S: about 12.9 GB
  So TQ3_1S is about 10% smaller while staying near Q4_0 quality. The practical point for me is simple:
  - TQ3_1S fits fully on my 16GB RTX 5060 Ti
  - Q4_0 does not fit fully on GPU in the same setup
  So I’m not claiming “better than Q4_0” in general. I’m claiming something narrower and, I think, useful:
  - near-Q4_0 quality
  - materially smaller than Q4_0
  - enough to make a 27B model practical on a 16GB card
  Speed record during perplexity test:
  - prompt processing pp512: 130.87 tok/s - generation tg10: 15.55 tok/s
  
  Caveats
  - this is the strongest result on the 27B witness, not a blanket claim that plain TQ3 works equally well on every model size
  - I am pretty new to this, so I may miss a lot of test. I only have one card to test :-)
  - Be skeptical as I can't believe I publish my own model
  - the speed story here is mainly a deployment/fit win on this GPU class, not a blanket claim that native TQ3 kernels are always faster than native Q4_0
  Links
  
  I will open source the quantization steps when I have enough feedback and test. Update: Since a few saying I only compare to q4_0. Here is update. TQ3_4S will be published with faster processing speed | Format | bpw | PPL (c=2048) | Size
  ---|---|---|---
  |
  TQ3_4S | 4.00 | 6.7727 | 12.9 GB
  Q3_K_S | 3.44 | 6.7970 | 11.4 GB
  IQ4_XS | 4.25 | 6.8334 | 13.9 GB
  TQ3_1S | 4.00 | 6.9186 | 12.9 GB
  UD-Q2_K_XL | 3.30 | 7.5294 | 11.0 GB
  
  - u/Imaginary-Anywhere23
  
  submitted by /u/pmttyji
  [link] [comments]
15. 🔗 r/wiesbaden Where can I go to get a couple holes in a belt? rss
  
  I have a couple of belts that need extra holes. In my home country, I'd take it to a shoe repair shop. Where can I do this here in Wiesbaden?
  
  submitted by /u/ExistentialRacoon
  [link] [comments]
16. 🔗 r/wiesbaden Friseur gesucht rss
  
  Gibt es in Wiesbaden einen Friseur, der/die Strähnchen macht, die nicht 150 Euro + kosten? 😅
  
  Ich hätte es echt nötig, aber kann mir das echt grad nicht leisten…
  
  Vielleicht kennt jemand jemanden?
  
  Danke euch schon mal! 🙂
  
  submitted by /u/Haunting-Ad2182
  [link] [comments]
17. 🔗 r/Yorkshire Countering the Sheffield Flags-On-Lamposts Group Protest on Saturday 4th April rss
  
  | submitted by /u/EchidnaMaleficent588
  [link] [comments]
  ---|---
18. 🔗 huggingface/candle 0.10.1 release
  
  v0.10.1
19. 🔗 mandiant/capa v9.4.0 release
  This release includes Ghidra PyGhidra support, performance improvements, dependency updates, and 26 new rules. We'd like to thank the following contributors: @devs6186, Daniel Adeboye (@AdeboyeDN), Aditya Pandey (@EclipseAditya), aryanyk, Ben Knutson (@blenbot), @CosmoWorker, kamran ul haq (@kami922), @Maijin, @res2500, and others!
  
  New Features
  - ghidra: support PyGhidra @mike-hunhoff #2788
  - vmray: extract number features from whitelisted void_ptr parameters (hKey, hKeyRoot) @AdeboyeDN #2835
  Breaking Changes
  
  New Rules (26)
  - nursery/run-as-nodejs-native-module mehunhoff@google.com
  - nursery/inject-shellcode-using-thread-pool-work-insertion-with-tp_io still@teamt5.org
  - nursery/inject-shellcode-using-thread-pool-work-insertion-with-tp_timer still@teamt5.org
  - nursery/inject-shellcode-using-thread-pool-work-insertion-with-tp_work still@teamt5.org
  - data-manipulation/encryption/hc-256/encrypt-data-using-hc-256 wballenthin@hex-rays.com
  - anti-analysis/anti-llm/terminate-anthropic-session-via-magic-strings wballenthin@hex-rays.com
  - nursery/access-aws-credentials maximemorin@google.com
  - nursery/access-cloudflare-credentials maximemorin@google.com
  - nursery/access-docker-credentials maximemorin@google.com
  - nursery/access-gcp-credentials maximemorin@google.com
  - nursery/access-kubernetes-credentials maximemorin@google.com
  - nursery/enumerate-aws-cloudformation maximemorin@google.com
  - nursery/enumerate-aws-cloudtrail maximemorin@google.com
  - nursery/enumerate-aws-direct-connect maximemorin@google.com
  - nursery/enumerate-aws-ec2 maximemorin@google.com
  - nursery/enumerate-aws-iam maximemorin@google.com
  - nursery/enumerate-aws-s3 maximemorin@google.com
  - nursery/enumerate-aws-support-cases maximemorin@google.com
  - persistence/registry/persist-via-shellserviceobjectdelayload-registry-key xpzhxhm@gmail.com
  - nursery/get-http-response-date @CosmoWorker
  - host-interaction/process/create/create-process-in-dotnet moritz.raabe@mandiant.com social.tarang@gmail.com
  - nursery/read-file-in-dotnet moritz.raabe@mandiant.com anushka.virgaonkar@mandiant.com
  - nursery/write-file-in-dotnet william.ballenthin@mandiant.com anushka.virgaonkar@mandiant.com
  - nursery/escalate-privileges-via-commit_creds-on-linux aryanyk
  - nursery/register-netfilter-hook-on-linux aryanyk
  - nursery/get-custom-http-header @msanchit-dev
  Bug Fixes
  - main: suggest --os flag in unsupported OS error message to help users override ELF OS detection @devs6186 #2577
  - render: escape sample-controlled strings before passing to Rich to prevent MarkupError @devs6186 #2699
  - rules: handle empty or invalid YAML documents gracefully in Rule.from_yaml and get_rules @devs6186 #2900
  - Fixed insecure deserialization vulnerability in YAML loading @0x1622 (#2770)
  - loader: gracefully handle ELF files with unsupported architectures kamranulhaq2002@gmail.com #2800
  - loader: handle SegmentationViolation for malformed ELF files @kami922 #2799
  - lint: disable rule caching during linting @Maijin #2817
  - vmray: skip processes with invalid PID or missing filename @EclipseAditya #2807
  - features: fix Regex.get_value_str() returning escaped pattern instead of raw regex @EclipseAditya #1909
  - render: use default styling for dynamic -vv API/call details so they are easier to see @devs6186 #1865
  - loader: handle struct.error from dnfile and show clear CorruptFile message @devs6186 #2442
  - address: fix TypeError when sorting locations containing mixed address types @devs6186 #2195
  - loader: skip PE files with unrealistically large section virtual sizes to prevent resource exhaustion @devs6186 #1989
  - engine/render: fix unbounded range sentinel precedence so count(...): N or more uses explicit ((1 << 64) - 1) @blenbot #2936
  - cache: support *BSD @williballenthin @res2500 #2949
  capa Explorer Web
  - webui: fix 404 for "View rule in capa-rules" by using encodeURIComponent for rule name in URL @devs6186 #2482
  - webui: show error when JSON does not follow expected result document schema; suggest reanalyzing for VT URLs @devs6186 #2363
  - webui: fix global search to match feature types (match, regex, api, …) @devs6186 #2349
  capa Explorer IDA Pro plugin
  
  Performance
  - perf: eliminate O(n²) tuple growth and reduce per-match overhead @devs6186 #2890
  Development
  - doc: document that default output shows top-level matches only; -v/-vv show nested matches @devs6186 #1410
  - doc: fix typo in usage.md, add documentation links to README @devs6186 #2274
  - doc: add table comparing ways to consume capa output (CLI, IDA, Ghidra, dynamic sandbox, web) @devs6186 #2273
  - binja: add mypy config for top-level binaryninja module to fix mypy issues @devs6186 #2399
  - rules: pre-filter extracted bytes with 4-byte prefixes for faster candidate selection instead of linear scan #2128
  - ci: deprecate macos-13 runner and use Python v3.13 for testing @mike-hunhoff #2777
  - ci: pin pip-audit action SHAs and update to v1.1.0 @kami922 #1131
  Raw diffs
  - capa v9.3.1...v9.4.0
  - capa-rules v9.3.1...v9.4.0
20. 🔗 r/Leeds Anyone know/guess where in LS28 the new iteration of Silver’s Deli is opening? rss
  
  I’m basically just nosey and impatient. Been teased on insta this week.
  
  submitted by /u/peachy4321
  [link] [comments]
21. 🔗 Luke Muehlhauser Media diet for Q1 2026 rss
  Music
  
  Music I most enjoyed discovering this quarter:
  - Marc Mellits: "Eclipse" (2022)
  - Ronan Hardiman: "Victory" (1995)
  - Rene Aubry: some of Signes (1997), some of Plaisirs d 'amour (1998), "Steppe" & "Faceties" (acoustic versions) (2008), "The Snail and the Whale (2019), some of Maria reve (2022)
  - London Grammar: "Wicked Game" (2013), "Nightcall" (2013)
  - Florence & the Machine: "Stand By Me" (2016)
  - Seinabo Sey: "Pistols At Dawn" (2014)
  - Anna Meredith: "Orca" (2012), "Unicron" & "Orlock" (2013), "Paramour" (2019)
  - Nik Bartsch: some of Spin (2024)
  - Maybeshewill: I Was Here for a Moment, Then I Was Gone (2011)
  - Ferry Corsten: "Adagio for Strings" (1999)
  - Rank 1: "Sensation Anthem 2003" (2003)1
  - Yndi Halda: Under Summer (2016)
  - Carla Bley: Blue Palestine mvts 1, 2, 4 (2018)
  - Red Snapper: "Ban-Di-To" (2025)
  - Bobby Previte: most of Set the Alarm for Monday (2008)
  - Present: "Contre" (2024)
  - Shibusashirazu: some of Dettaramen (1993), some of Something Difference (1994), some of Shibuzen (2006), Sakuraza Mon (2025)
  - Daisuke Fuwa: some of Chitei Records Works (2012)
    
    With these new listens, Shibusashirazu / Daisuke Fuwa have crossed the 5-hour mark as one of my favorite musical artists!
  - The Physics House Band: Horizons / Rapture (2013), Mercury Fountain (2017), Death Sequence (2019)
  - Jeremy Dutcher: Wolastoqiyik Lintuwakonawa (2018)
  - Tina Guo: some of Game On! (2017)
  - The 8-Bit Big Band: some of Press Start! (2018), some of Choose Your Character! (2019), some of Backwards Compatible (2021), "Song of Storms" (2023), some of Orchestrator Emulator (2025)
  - Sheena Ringo: Shouso Strip (2000), Kalk (Bleach), Semen, Chestnut Blossoms (2003)
  - Wim Mertens: some of Music and Film (2006)
  - Turtle Island String Quartet: "Street Stuff" (1989), "Near Northern" (1995)
  - David Balakrishnan: "Syzygy" (2018)
  - Desmond Earley: "Dulaman" (2019)
  - Andries van Tonder: "Siyahamba" (1950)
  - Michael Barrett: "Thixo Onothando" (2016)
  - Brad Richmond: "Ipharadisi" (2002)
  - Ishmael Morabe: "Avulekile Amasango" (2001)
  - Theresa Clements & Thomas Shadrach James: "Bura Fera" (1886)
  - Lebo M: "One by One" (1995)
  - Ladysmith Black Mambazo: "Awu Wemadoda" (1973)
  - Brian Tate: "Gate Gate" (1998)
  - James Horner: "Sacred Guardian of the Mountain" & "Dedication and Windsong" (1998)
  - Audiomachine: some of The Platinum Series I (2007), "The Dark Knight" & "The Illusionist" (2008), some of The Platinum Series III (2009), "Ad Suprema" (2009), some of The Platinum Series IV (2010), some of Chronicles (2012), some of Tree of Life (2013), some of Decimus (2015), some of Life (2017), some of Worlds of Wonder (2017), some of La Belle Époque (2018), some of Another Sky (2020), "Unrelenting Desires" (2024), some of Even Poets Go to War (2024)
  I also listened to a significant portion of the recorded works by each of the (new-to-me) composers listed below.2 My favorites pieces from them (names linked to playlists) were:
  - Oliver Davis (b. 1972): most of Flight (2015), most of Dance (2016), most of Liberty (2018), most of Arcadia (2019), most of Solace (2021), some of Air (2022), most of Blue (2023), most of Life (2025)
    
    With these new listens, Davis has crossed the 5-hour mark as one of my favorite musical artists!
  - Marcus Paus (b. 1979): Decameron mvt 10 (2020), Tuba Mirum (2021), The War Cross mvt 15 (2023)
  - Federico Jusid (b. 1973): Tango Rhapsody mvt 3 (2010), Isabel "A Todo Galope" (2013), The English "Opening Credits" (2022)
  - Vladimir Martynov (b. 1946): Requiem "Sequentia" (1998), Passionslieder "Kommunionsgesange" (1977)
  - Aleksey Igudesman (b. 1973): Koberia Fantasy (2018), Joyful Variations (2020), Peace-acaglia (2024)
  - Russell Peck (b. 1945): some of Signs of Life II (1986)
  - Giancarlo Castro D'Addona (b. 1980): Concerto for Clarinet & Big Band (2005?), Tuba Concerto (2007), "Walking Faster" (2009), Concierto Sureño (2010), "Rhapsody for Talents" (2013), "Melk Abbey" (2017?)
  - Alexis Aranda (b. 1974): Concierto de Fuego para Violonchelo y Orquesta (2009), Piano Concerto No. 2 mvt 3 (2012), Flute Concerto “Acqua” mvts 2, 3 (2013), Double Concerto for Flute & Guitar mvts 1, 3 (2017)
  - Andrew Pearce (b. 1975): some of Maison Yves Rocher (2018)
  - Peter Breiner (b. 1957): some of Songs and Dances from the Silk Road (2003), Beatles Concerti Grossi Nos. 1-4 (1986), Beatles Concerti Grossi 5-9 (2018)
  - Tarquinio Merula (b. 1595): "Ciaccona" (1637)
  - Stuart Hancock (b. 1975): Violin Concerto mvt 3 (2005), "Variations on a Heroic Theme" (2007)
  - Daniel Freiberg (b. 1957): Latin American Chronicles mvt 3 (2015), Northern Journey (2017)
  - Loris Tjeknavorian (b. 1937): Dances Fantastic mvt 7 (1993), Ararat Suite mvts 3, 5, 7 (1998)
  - Srul Irving Glick (b. 1934): Old Toronto Klezmer Suite mvt 1 (1998)
  - José Alberto Pina (b. 1984): "A Mi Banda" (2003), "Himne a la Festa" (2006), "Crucifixus" (2008), The Bermuda Triangle (2009/2013), "Es Vedra" (2010), "The Legend of Maracaibo" (2011), The Island of Light (2013), The Ghost Ship (2017), Pompeii (2019), Dunkirk (2020), Sajelbon (2021), "Steel Overture" (2022), "Excalibur" (2023), "The Ambitious Plan" (2023), "The Scary Mountains" (2024), "Promesa" (2025), Cleopatra (2025)
  - Takashi Kako (b. 1947): "Medina" (1990), "The Wind of Gibraltar" (1992), Passage of the Gods mvts 1, 3 (2006)
  - Gediminas Gelgotas (b. 1986): "Extracadenza" (2015)
  - Krzesimir Debski (b. 1953): some of With Fire and Sword (1999), some of Ancient Tale (2003)
  - Kirill Richter (b. 1989): some of Chronos (2019), "In Memoriam" (2019), "Waltz No. 1" & "Waltz No. 3" (2025)
  - Saul Gomez Soler (b. 1982): some of Suite Al’Ariba (2018), "Gioia" (2020)
  - Alex Poelman (b. 1981): "1944" (2021)
  - Matej Mestrovic (b. 1969): some of Eat Suite (2014), Danube Rhapsody mvts 1, 2, 4 (2015), Chinese Rhapsody (2015), New England Rhapsody (2015), "Pleter" (2022)
  - Vaja Azarashvili (b. 1936): Piano Concerto No. 2 (2023)
  - Murat Kabardokov (b. 1986): "Baso Ostinato" (2015?), "Alla Barocco" (2015), Above the Mountains "Main Theme" (2017), "Hunderkuakua" (2021)
  - Masamichi Amano (b. 1957): "Tragedy Occurs Again" (1993), "Spy Swordsman Jubei and the Fivefold Group" (1998), "New Departure" (2000)
  - Can Atilla (b. 1969): "Yine Gel Ne Olursan Ol" (2008), Symphony of Love (2024)
  - Kim Andre Arnesen (b. 1980): "Cry of the Sea" & "The Strangers" (2016), Holy Spirit Mass "Amen" (2017)
  - Alexey Rybnikov (b. 1945): "Adagio for Cello & Strings in D Minor" (1981), Concerto Grosso No. 2 (2006)
  - Olli Mustonen (b. 1967): Concerto for 3 Violins mvts 1, 2, 4 (1998)
  - Vladimir Cosma (b. 1940): "Danse roumaine" (1972)
  - Harry Stafylakis (b. 1982): "Brittle Fracture" (2013), Arc of Horizon (2015), "Sun Exhaling Light" (2017), Symphony No. 1 "Holocene Extinction" (2017), "Atlas" (2018), Weighted (2019), "Source Code" (2019), "Focus" (2019), "To Wake and Find the World Still Burning" (2022), "Incinerate" (2022), Calibrating Frictions [album] (2023), Piano Concerto No. 1 "Mythos" (2023), Violin Concerto "On a Path to Singularity" (2024)
  - Joey Roukens (b. 1982): In Unison mvt 1 (2017)
  - Lee Che-Yi (b. 1970): Dancing Strings mvts 1 & 2 (2011), Lukang Impression (2017), Four Seasons in the Peach Garden mvt 4 (2018)
  - Jim Bonney (b. 1971): Chaos Theory (2000)
  - Chiel Meijering (b. 1954): "Slash" (1995), "The truth requires a hairier buck" (1996), "Rip Off" & "Joe Montana" (2001), "Joke" & "The Roof of Blue Glass" & "Rondo" (2007), The Pied Piper mvt 4 (2012)
  - Andy Scott (b. 1966): Dark Rain (2005), "Three Letter Word" (2010), Spirit of Mingus (2012)
  - Sergei Akhunov (b. 1967): Le quattro stagioni (2011)
  - Anton Batagov (b. 1965): Bodhicharyavatara "Adopting the Spirit of Awakening" (2009), The One Thus Gone mvt 4 (2016)
  - Howard Blake (b. 1938): Four Miniatures (orchestral) (1964), Concert Dances mvt 5 (1992)
  - Alexandre Rabinovitch-Barakovsky (b. 1945): La belle musique No. 3 (1977), Musique populaire (1980), "Liebliches Lied" (1980), Discours sur la delivrance (1982), La belle musique No. 4 (1987), Das tibetanische gebet (1987), 3 Invocations (1996), Incantations (1996), Schwanengesang an Apollo (1996), La triade (1998), Les six etats intermediaires (1998), Die Zeit (2000), Jiao (2004), Maithuna (2005)
    
    With these new listens, Rabinovitch-Barakovsky has crossed the 5-hour mark as one of my favorite musical artists!
  - Sven Helbig (b. 1968): some of Pocket Symphonies (2013)
  - Yasushi Akutagawa (b. 1925): some of Village of Eight Gravestones (1977), Village of Eight Gravestones Suite (1977), Mt. Hakkoda Suite (1977)
  - Arash Safaian (b. 1981): UberBach (2016), This Is (Not) Beethoven (2019), "Lara" (2019), "Marie's Piece" (2023)
  - Michael Kurth (b. 1971): "May Cause Dizziness" (2010), Everything Lasts Forever mvt 3 (2012), A Thousand Words mvts 2, 3, 4 (2015), some of Miserere (2017), Origin Story (2023), "All Will Be Revealed" (2023), "Suspectivish" (2025)
  - Alexey Kurbatov (b. 1983): Sextet "Train" (2016)
  - Polina Nazaykinskaya (b. 1987): Nostalghia (2018), "A Summer Rain" & "Remembrance" (2020), "Songs for Tasya" (2021), Emily mvt 1 (2023)
  - Victoriano Valencia (b. 1970): "Siete Colores" (2003), "Sanjuanito" (2003), "Fandanguillo" (2003), Suite No. 1 (2003), "Gualajo y Candelo" (2004), "Leon Bambuco" (2004), "San Pelayo" (2005), "La gaïta de Arlington" (2006), Suite No. 2 (2007), "Fandanguería" (2007), "Mayito" (2007), "Juana Jacinta" (2008), "Espiritu" (2009), "El Mono" (2011), "Balin" (2012), Ritmos de la Tierra (2013), Suite de los Juegos (2013), "Macondo" (2015), "Puyax" (2017), Concerto for Clarinet & Band (2018), Concerto for Saxophone & Band (2019), Fandango! Secretos de La Rueda Oscura (2022)
  - Fahir Atakoglu (b. 1963): "Med Cezir" (1993), "12 + Lai" & "Yesilada" & "Demirkirat" & "Vals" (1994), some of East Side Story (2005), 15 Temmuz Destani (2020)
  - Roland Szentpali (b. 1977): "Blow on Fire" & "Cinder Dance" (2007), "Carmen Fantasy" (2007)
  - Giovanni Allevi (b. 1969): "Angelo Ribelle" (2006), "Mandella" (2012), Violin Concerto "La danza della strega" (2012), Piano Concerto No. 1 mvts 1, 3 (2017)
  - Kinan Azmeh (b. 1976): "Love on 139th Street in D" (2005), Ibn Arabi Suite mvt 3 (2013), In the Element mvt 3 (2018)
  - Pacho Flores (b. 1981): Cantos y Revueltas (2018), Albares (2022)
  - Masanori Taruya (b. 1978): "A Picture Book Without a Picture" & "Liberty Guiding the People" & "Magellan's Voyage to Unknown Continent" (2004), "Tears of the Princess Kushinada Flowing in Hii" (2012)
  - Li Bochan (b. 1992): "Ode to Chu" (2014), "Late Autumn" (2014), "Chant on Strings" (2016), "Bamboo Stone" (2017)
  - Cristian Carrara (b. 1977): Destinazione del Sangue mvt 3 (2008), "East West Romance" (2009), "A Little Tango to My Wife" (2011), "Liber Mundi" (2012), Slot Machine mvt 3 (2014), Machpelah mvt 2 (2015)
  - Andrew Staniland (b. 1977): The Laws of Nature mvts 1, 2 (2025)
  - Ilari Hylkila (b. 1978): "Return to the Indian Valley" (2002), "Reflection of Destiny" (2002), "Force" (2003), "Honor March" (2003), "Tristesse" (2003), "Dance of Giants" (2004), "Unknown Legend" (2005), "The Zest" (2007), "Hero Tale" (2008), "Sinia" (2008), "Cinclus Arctica" (2010), "Magical Forest" (2010), "Metalflare" (2010), "Nimia" (2012), "Sankar" (2012), "Waltz Unforgettable" (2014), "Wonderworld" (2014), Into the Wind (2015), "My Christmas Dream" (2016), "Taiga" (2018), "Dark" (2018), "Adorable Creatures" (2018), Saga (2018), "Yet" (2018), Lapland Imagery mvts 1, 5 (2020), "Echoes from Central Finland" (2025)
  - Kristjan Jarvi (b. 1972): "Aurora" (2016), "Kritical Mass" (2017), "Midnight Sun" (2019)
  - Mily Balakirev (b. 1837): Symphony No. 1 mvt 2 (1898)
  - Marcus Warner (b. 1996): "Africa" (2014), some of Oceans (2016), "Wintersong" (2017), "Tokyo Rain" & "Helsinki" (2018)
  - Efrain Oscher (b. 1974): some of Barroqueana Venezolanas 1-4 (2017), Barroqueana Sudamericana No. 1 (2018), Danzas Latinas (2019)
  - Wang Jianmin (b. 1956): Erhu Rhapsody No. 6 (2023)
  - Aldo Lopez-Gavilan (b. 1979): "Pan Con Timba" (2005), "La Jutia Preguntona" (2009), "Oddudua" (2011), "Epilogo" (2012)
  - Tuluyhan Ugurlu (b. 1968): "Yaşamımız Bu Toprakta" & "Allaturca" (2002), "A World Capital Istanbul" (2006)
  - Fang Dongqing (b. 1981): "A Dance of Fire" (2016)
  - Francisco Valor Llorens (b. 1979): most of Creu Daura (2006), Llegenda (2014), Dolca Mareta, les Llagrimes de Maria (2021), most of Francisco Valor in Live (2021), Mazon (2023), some of Suite Alcodianima (2023), some of Crucis Petra (2023), plus dozens of other short compositions
    
    With these new listens, Valor Llorens has crossed the 5-hour mark as one of my favorite musical artists!
  - Hayato Hirose (b. 1974): "Marching Blues" (2005), "Norman Rockwell Suite" (2006), "The Bell of Hope" (2010)
  - M.M. Keeravani (b. 1961): Baahubali "Wkkb" (2015), RRR "The Water" (2022)
  - Rafael Mullor Grau (b. 1962): "Un moro mudejar" (1981)
  - Jose Rafael Pascual Vilaplana (b. 1971): "Cavall de Foc" (1996), "Jessica" (2000), "Falhanis" (2015), Out of Earth mvt 3 (2015), "Hernandiana" (2017)
  - Florian Christl (b. 1990): some of Inspiration (2018), "Glass" & "Timelapse" (2022), "Vienna" (2024)
  - Michele Mangani (b. 1966): "Clarinettomania" (2015), Clarinet Concerto mvts 1, 3 (2018)
  - Nancy Galbraith (b. 1951): "Danza de los Duendes" (1991), "Febris Ver" (2011), "Euphonic Blues" (2012), Effervescent Air (2012), Strange Travels (2013), Violin Concerto No. 1 mvts 1, 3 (2016), Everything Flows (2019)
  - Jose Maria Vitier (b. 1954): Mediopunto mvts 1, 3 (1977), Vitral mvts 1, 3 (1982), "Contradanza festiva" (1991), "Epílogo" (1993), "Rítmico" (2012)
  - José Suñer-Oriola (b. 1964): Vasa mvts 1, 3 (1999), El Jardín de las Hespérides mvt 4 (2014)
  - Ramón García i Soler (b. 1971): Oryza (2015)
  - Armand Amar (b. 1953): "To amo" & "La terre vue du ciel" (2004), "Mere et enfant" (2005), some of Home (2009), "La vallee de la solitude" (2014), some of Human (2015), some of L 'histoire de l'amour (2016), "Arrivee a Nice" & "La traversee" (2017)
  - Christopher Stark (b. 1980): "Velocity Meadows" (2015)
  - Hardy Mertens (b. 1960): "Viva El Litro" (2008)
  - Marek Bednar (Marc Cooper) (b. 1985): "Violin Sonata in E Minor" & "Flash Flood" & "Violin Concerto in D Minor" (2025), "The Awakening of Spring" & "The Weimar Punk-Opera" (2026)
  - George Deac (b. 1970): "Modul X-01" & "Polonaise: The Emperor's Entrance" & "Metamorphosis" & "Neon Shadows" & "The Hero's Return" & "Midnight in Andalusia" & "The Clockwork Machine" & "Elegy for a Forgotten Princess" & "The Broken Waltz" & "St. Petersburg Nocturne" & "Clarinet Dance in Central Park" & "Starlight Farewell" & "Oracle of the Cold Moon" (2026)
  - Mario Burki (b. 1977): "Napoleon" (2009), "Milestone" (2013), La Corrida de Toros (2016), Utinam (2021)
  - Roland Batik (b. 1951): Piano Concerto No. 1 mvt 3 (1993)
  - Gordon Hamilton (b. 1982): "Baby Steps First" (2014), Thum Prints (2015), "482 Variations on a Very Short Theme" (2016)
  - Simon Dobson (b. 1981): "Firefly" (2015), "Clash" (2016)
  - Hugo Chinesta (b. 1977): The Gates of the Alhambra mvt 4 (2007), The Angel of the Apocalypse (2019)
  - Valgeir Sigurosson (b. 1971): "Past Tundra" (2011), "Ancor che col partire" (2013)
  - MAias Alyamani (b. 1981): "Dance" & "Zainno el Marje" (2010), most of White (2011), "Al Ad'am" (2012), most of Offstage (2014), most of A Decade of MAqam Ensemble (2018), "Najaz" (2019), "Reborn" (2020)
  - Dimitri Cervo (b. 1968): "Uguabe" (1999), "Toronuba" (2000), "Brasil Amazonico" (2005), "Toro-Lobiana" (2007), Flute Concerto mvts 1, 3 (2008), "Abertura Brasil 2012" (2012), "Abertura 2014" (2014), Suite Concertante (2017), "Abertura Brasil 2018" (2018), Trombone Concerto (2018)
  - Nuno Corte-Real (b. 1971): Folias (2024)
  - Juan J. Colomer (b. 1966): some of Sorolla: Vision of Spain (2013), Sorolla Breve Suite (2022)
  - Vakhtang Kakhidze (b. 1959): "Satyr's Dance" (1989), Blitz Fantasy mvt 4 (2000)
  - Abraham Cupeiro (b. 1980): some of Os Sons Esquecidos (2017), Pangea (2020), some of Mythos (2024)
  - Tielman Susato (b. ~1510): some of Danseyre (1551)
  - Chen Gang (b. 1935): "Golden Hearth" (1972), "Deep Gratitude" (1974), "Drum and Song" (1976)
  - Gauthier Dupertuis (b. 1997): "Terminal" (2025)
  - Katahj Copley (b. 1998): "Grosso Blue" (2018), "HayWire" (2018), "Infinity" (2020), "Halcyon Hearts" (2021), "In Living Color" (2021), "Uptilt" (2021), "Equinox" (2021), "Havens" (2022), "Iridessi" (2023)
  - Jeff Tyzik (b. 1951): "Fire Dance" (1978), "Blues Suite for String Orchestra" (1985), "Skater's Overture" (1996), New York Cityscape (2008), "Riffs" (2009), Images (2012), "Dream Sequence for Flute and Orchestra" (2015), "Three Latin Dances" (2018), "Give My Regards to George" (2020), Dance Suite for Oboe, String Orchestra, and Piano (2021), Jazz Concerto for Soprano Saxophone (2023)
  - Ricardo Molla Albero (b. 1992): Finisterrai (2022)
  - Nunzio Ortolano (b. 1967): "Russian Melodies" (1999), "Texas" (2000), "Event" (2001), "Giuditta" (2001), "Preludio e Marcia" (2001), "I Tre Puntini" (2005), "Prelude for Concert" (2007), "Manola" (2008), "Tano Tano" (2014)
  - Alexander Litvinovsky (b. 1962): some of Consort Lessons (1999), "Steps Upward" (2001), "Theatre" & "L'incendie" & "La fin de la guerre" (2015), "Procession du crepuscule" & "Melisande au rouet" (2021), "In fuga dai briganti" & "Volare sul Colombo" (2022), "Morning Jogging" & "Playful Goatlings" (2023), "Games and Fun (2024)
  - Soon Hee Newbold (b. 1974): "American Landscape" (2006), "Angel City" (2025), "The Iliad" (2025)
  - Greg Dombrowski (b. 1983): "Birth of a Hero" (2018), some of Heart of Darkness (2019), "Manifesto" & "Past in Flames" & "The Immortalist" (2020), "Reprise" (2020), "Born a Legend" & "To Boldly Go" (2021),
  - Anthony Fiumara (b. 1968): "As I Opened Fire" (2014), "Here Comes Everybody" (2017)
  - Jaz Coleman (b. 1960): Magna Invocatio (2018)
  - Lino Guerreiro (b. 1977): "Maud'Adib" (2008), "Fanfare Overture" (2013), "Mazurkax" (2014), "al-Uqsur" (2015), Balkan (2019)
  - Carlos Marques (b. 1973): "Artis Calambria" (2011)
  - Carl Wittrock (b. 1966): "Lord Tullamore" (2001), "Journey of the Half Moon" (2017)
  - Filippo Ledda (b. 1975): "Argon" (2018)
  - Marcel Khalife (b. 1950): "Mare" (1998), Andalusian Suite for Oud and Orchestra (2002), Sharq (2007), Arabian Concerto (2008), "Achikain" (2016)
  - Francois Rousselot (b. 1984): "New World Coming" & "The Lost World" & "World of Wonders" (2015), Live Epic Orchestra (2021), "Hope Is Reborn" & "Strat of Adventure" (2022), "Bird Flight" (2023), "Weigh Anchor" & "Raising the Sails" & "The Final Treasure" (2026)
  - David Fanshawe (b. 1942): "Trafalgar" (2005), Pacific Song mvts 2, 3 (2007)
  - Jim Papoulis (b. 1961): "Sing for Peace" (2004), "Can You Hear" (2005), "Oye" (2006), "Stand Together" (2008), "Kusimama" (2011), "Sililiza" (2012), "Juntos" (2013), "There Is Peace" (2015), "We Are the Voices" (2015), "Regalando Belleza" (2017), "Sing to Bring Us Together" (2018), "I Will Raise My Voice" (2019)
  - Gu Guanren (b. 1942): Spring Suite mvts 2, 3, 5 (1979)
  - Robert Davidson (b. 1965): From to Here (2020)
  - Guido Lopez-Gavilan (b. 1944): "Camerata en Guaguanco" (1983), Por el Mar de las Antillas Anda un Violin mvt 3 (2003), "Ritmotiv" (2006)
  - Lukas Hurnik (b. 1967): Variations on the Theme by Frank Zappa (2003)
  - Conni Ellisor (b. 1953): Blackberry Winter mvts 1, 3 (1995), "The Littlest Star" (2000), Broad Band of Light (2012), Tres Danzas de Vida mvt 3 (2013), "The Bell Witch Dances" (2014)
  - Iiro Rantala (b. 1970): "Pizzitaxi" (1990), "Topi" & "Final Fantasy" & "Tango Ouh" (1993), "Tango Dada" (1995), some of Sisu (1997), "Proko-type of Polka" & "Another Ragtime" (1998), Piano Concerto in G-Sharp Major / A-Flat Major mvt 3 (2002), "A Concert Tango" (2002), "Beba" & "Third Ball" (2005), Jouluoratorio "Intro" (2012), Veneziana (2023)
  - Azael Tormo Munoz (b. 1966): "Malaguenya de Barxeta" (2018), "Escenas de Carnaval" (2024)
  - Christiaan Janssen (b. 1974): "Impresiones de Estepona" (2024)
  - Randall Standridge (b. 1976): "Choose Joy" (2022), "Groovitude" (2025)
  - Timothy Shortell (b. 2002): "Onward" (2019), "Convergence" & "Shattered Destiny" (2020)
  - Law Wai Lun (b. 1944): Prince Sang Nila Utama and Singa (2003), The Celestial Web (2003), Journey Through Taoyuan mvts 1,3 (2021)
  - Philippe Geiss (b. 1961): "Medina" (2004), United Colors of Saxophones (2009), "Foxy Music" (by 2011), "Sax Heroes" (2011), "Sir Patrick" (2012), "Klezmer Salsa" (by 2012), "Zerbace" (2016), several other short pieces (years unknown)
  - Francois Dompierre (b. 1943): Piano Concerto in A Major (1978), Les Diableries mvts 3, 5 (1979), "Celeste" (1988), "Maxime Theme" (1994), "Frenetique" (2012), "Partance" (2022)
  - Wlodek Pawlik (b. 1958): "Let's All Go to Heaven" & "Magic Seven" (2009), some of Night in Calisia (2013), some of America (2015)
  - Clint Needham (b. 1981): "Urban Sprawl" (2011), "Free Radicals" (2017)
  - Plus the following composers for which I didn't "strongly like" any of their pieces I listened to: Leo Brouwer (b. 1939), Soren Hyldgaard (b. 1962), Efrem Podgaits (b. 1949), Karol Beffa (b. 1973), Fabien Waksman (b. 1980), Eric Tanguy (b. 1968), Robin Holloway (b. 1943), Peter Seabourne (b. 1950), Rick Sowash (b. 1950), Fabian Muller (b. 1964), Jerome Ducros (b. 1974), Kareem Roustom (b. 1971), John Estacio (b. 1966), Joep Franssens (b. 1955), Richard Galliano (b. 1950), Herman Beeftink (b. 1953), Lorenzo Palomo (b. 1938), Ian Clarke (b. 1964), Stephen Lias (b. 1966), Jeff Manookian (b. 1953), Gabriela Montero (b. 1970), Jukka Linkola (b. 1955), Ney Rosauro (b. 1952), Boris Pigovat (b. 1953), Bert Appermont (b. 1973), Ilya Demutsky (b. 1983), Paul Desenne (b. 1959), Gonzalo Grau (b. 1972), Franco Cesarini (b. 1961), Kassia (b. ~810), Alexander Comitas [Eduard de Boer] (b. 1957), Yared (b. 505), Kevin Lau (b. 1982), Jiang Kui (b. 1155), Wlad Marhulets (b. 1986), Ofer Ben-Amots (b. 1955), Paul Dresher (b. 1951), Valery Gavrilin (b. 1939), Ugis Praulins (b. 1957), Alla Pavlova (b. 1952), Esteban Benzecry (b. 1970), Kaoru Wada (b. 1962), Jose Elizondo (b. 1972), Jerod Impichchaachaaha' Tate (b. 1968), Paul Hart (b. 1945), Julian Cochran (b. 1974), Juan Pablo Contreras (b. 1987), Kalevi Aho (b. 1949), Joel Puckett (b. 1977), Tania Leon (b. 1943), Stamatis Spanoudakis (b. 1948), Thierry Deleruyelle (b. 1983), Fernando Velazquez (b. 1976), Arturo Rodriguez (b. 1976), Anton García Abril (b. 1933), Luis Serrano Alarcon (b. 1972), Enjott Schneider (b. 1950), Paul Carr (b. 1961), Kevin Houben (b. 1977), Addie Muljadi Sumaatmadja (b. 1959), Ryan Cayabyab (b. 1954), Ashenafi Kebede (b. 1938), Ahmad Pejman (b. 1935), Adil Bestybayev (b. 1959), Fred Onovwerosuoke (b. 1960), Narongrit Dhamabutra (b. 1962), Nkeiru Okoye (b. 1972), Justinian Tamusuza (b. 1951), Christian Onyeji (b. 1967), Vu Viet Anh (b. 1978), Nguyen Van Nam (b. 1932), Majid Entezami (b. 1948), Muammer Sun (b. 1932), Cetin Isikozlu (b. 1939), Dnu Huntrakul (b. 1950), Josefino "Chino" Toledo (b. 1959), Njane Mugambi (b. 197?), Shaka Marko (b. 2000), Francisco Zumaque (b. 1945), Jorge Pinzon (b. 1968), Victor Agudelo (b. 1979), Ali Osman (b. 1958), Salim Dada (b. 1975), Steve Dobrogosz (b. 1956), Luke Howard (b. 1978), Ante Grgin (b. 1945), Eleni Karaindrou (b. 1939), Ara Gevorgyan (b. 1960), Francesco Tristano (b. 1981), Leonid Desyatnikov (b. 1955), Osama Abdulrasol (b. 1968), Rahim AlHaj (b. 1967), Taro Iwashiro (b. 1965), Stacy Garrop (b. 1969), Marc-Andre Hamelin (b. 1961), Fernando Otero (b. 1972), Koichi Sugiyama (b. 1931), Robert Jager (b. 1939), Peeter Vahi (b. 1955), Bill Douglas (b. 1944), Alexander Peskanov (b. 1955), Paul Reade (b. 1943), Ma Shui-long (b. 1939), Aldemaro Romero (b. 1928), Murad Kazhlayev (b. 1931), Albert Schnelzer (b. 1972), Mike Mower (b. 1958), Tobias Brostrom (b. 1978), Eugen Doga (b. 1937), Erkki-Sven Tuur (b. 1959), Vincent Ho (b. 1975), Yasuhide Ito (b. 1960), Valerie Coleman (b. 1970), Enrico Chapela (b. 1974), Dan Visconti (b. 1982), Bernhard Gander (b. 1969), Gian Piero Reverberi (b. 1939), Stewart Copeland (b. 1952), Holly Harrison (b. 1988), Earl Maneein (b. 1976), David Wallace (b. 1970), Christian Kolonovits (b. 1952), Regis Campo (b. 1968), Richard Dubugnon (b. 1968), Gene Pritsker (b. 1971), B. Tommy Andersson (b. 1964), Go Shiina (b. 1974), Pierre Jalbert (b. 1925), Robert Paterson (b. 1970), Paul Stanhope (b. 1969), Rene Eespere (b. 1953), Hanna Kulenty (b. 1961), Mieczyslaw Weinberg (b. 1919), Arno Babajanian (b. 1921), Andrei Eshpai (b. 1925), Sulkhan Tsintsadze (b. 1925), Igor Frolov (b. 1937), Tikhon Khrennikov (b. 1913), Anatoly Lyadov (b. 1855), Blas Galindo (b. 1910), Boris Papandopulo (b. 1906), John White (b. 1936), York Bowen (b. 1884), Lars-Erik Larsson (b. 1908), Doreen Carwithen (b. 1922), Dag Wiren (b. 1905), Walter Piston (b. 1894), Radames Gnattali (b. 1906), Coleridge-Taylor Perkinson (b. 1932), Lera Auerbach (b. 1973), Dani Howard (b. 1993), Cheryl Frances-Hoad (b. 1980), Helen Grime (b. 1981), Caio Faco (b. 1992), Edward W. Hardy (b. 1992), Karin Rehnqvist (b. 1957), Kuzma Bodrov (b. 1980), Outi Tarkiainen (b. 1985), Augusta Read Thomas (b. 1964), George Benjamin (b. 1960), Mischa Zupko (b. 1971), Heather Schmidt (b. 1974), Uljas Pulkkis (b. 1975), Richard Prior (b. 1966), Wouter Lenaerts (b. 1981), Kevin Day (b. 1996), Bechara El-Khoury (b. 1957), Francisco Jose Martinez Gallego (b. 1969), Leszek Mozdzer (b. 1970), Chang Su Koh (b. 1970), Alexander Tchaikovsky (b. 1946), Christian Lindberg (b. 1958), Mikhail Bronner (b. 1952), Yo Goto (b. 1958), Andres Valero-Castells (b. 1973), Martin Romberg (b. 1978), Bob Chilcott (b. 1955), Krzysztof Herdzin (b. 1970), James Swearingen (b. 1947), Martin Bresnick (b. 1946), Torstein Aagaard-Nilsen (b. 1964), Ian Cusson (b. 1981), Ronaldo Miranda (b. 1948), Odaline de la Martinez (b. 1949), Jack Stamp (b. 1954), Anthony DiLorenzo (b. 1967), Andres Martin (b. 1981), Kow Otani (b. 1957), Tracy Silverman (b. 1960), Wang I-Yu (b. 1981), Peter Eotvos (b. 1944), Chris Thile (b. 1981), Jose Evangelista (b. 1943), Maxime Goulet (b. 1980), David Heath (b. 1958), Yosuke Fukuda (b. 1982), Gil Shohat (b. 1973), James Lee III (b. 1975), Ricardo Lorenz (b. 1961), Thierry Huillet (b. 1965), Sean O'Loughlin (b. 1972), Jake Runestad (b. 1986), Naji Hakim (b. 1955), David Rivas Domínguez (b. 1980), Nicola Campogrande (b. 1969), Eduardo Alonso-Crespo (b. 1956), Andrea Tarrodi (b.1981), Joe Cutler (b. 1968), Gordon Chin (b. 1957), Martín Palmeri (b. 1965), Thomas Hewitt Jones (b. 1984), Itaru Sakai (b. 1970), Elena Ruehr (b. 1963), Lorenzo Pusceddu (b. 1964), Joe Chindamo (b. 1961), Patrick Cassidy (b. 1956), Yasuharu Takanashi (b. 1963), Maximo Diego Pujol (b. 1957), Rihards Dubra (b. 1964), Stella Sung (b. 1959), Teo Aparicio-Barberán (b. 1967), John Harle (b. 1956), Gavin Higgins (b. 1983), Victoria Borisova-Ollas (b. 1969), Lev "Ljova" Zhurbin (b. 1978), Claudia Montero (b. 1962), Mikolaj Majkusiak (b. 1983), Rob Smith (b. 1968), Roshanne Etezady (b. 1973), Noizgenie (b. ????), Wings of Fates (b. 19??), Ruben Dario Gomez (b. 1973), Fritz Kreisler (b. 1875), Roberto Di Marino (b. 1956), Alexander L'Estrange (b. 1974), Nicholas Lens (b. 1957), Guillermo Lago (Willem van Merwijk) (b. 1960), Richard Einhorn (b. 1952), Dave Maric (b. 1970), Robert Honstein (b. 1980), Mikael Karlsson (b. 1975), Paul Halley (b. 1952), Hirokazu Fukushima (b. 1971), Carlos Pellicer (b. 1981), Ryan George (b. 1978), Armando Ghidoni (b. 1959), Eiji Suzuki (b. 1965), Richard Saucedo (b. 1957), Vivian Fung (b. 1975), Patrick Zimmerli (b. 1968), Gareth Glyn (b. 1951), Christopher Tyler Nickel (b. 1978), Aleksandar Simic (b. 1973), Wang Chenwei (b. 1988), Efrain Amaya (b. 1959), Veljo Tormis (b. 1930), Nikita Koshkin (B. 1956), Eduardo Gamboa (b. 1960), Hasan Niyazi Tura (b. 1982), Evencio Castellanos (b. 1915), Chung Yiu-Kwong (b. 1956), Anatoly Kalvarsky (b. 1934), John Carmichael (b. 1930), Vadim Bibergan (b. 1937), Charles Camilleri (b. 1931), Igor Andric (b. 1996), Qasim Naqvi (b. 1977), Milos Bok (b. 1968), Oguzhan Balci (b. 1977), Eduardo Angulo (b. 1954), Toshio Mashima (b. 1949), Tolibkhon Shakhidi (b. 1946), Andrey Rubtsov (b. 1982), Niels Marthinsen (b. 1963), Carlos Franzetti (b. 1948), Antti Martikainen (b. 1985), Jo Blankenburg (b. 1972), Jeroen D'hoe (b. 1968), Michael John Trotta (b. 1978), Hilarion Alfeyev (b. 1966), Filip Ceunen (b. 1983), Jesus Orielso Santiago Jacome (b. 1968), Juan Jose Ramírez Gomez (b. 196?), Nikola Resanovic (b. 1955), Yalil Guerra (b. 1973), Jaan Raats (b. 1932), Lior Navok (b. 1971), Alejandro Vinao (b. 1951), Gernot Wolfgang (b. 1957), Chris Pilsner (b. 1986), Jose Ignacio Blesa Lull (b. 1982), Mzilikazi Khumalo (b. 1932), Peter Louis van Dijk (b. 1953), Qinisela Sibisi (b. 1963), Santiago Quinto Serna (b. 1971), Jean-Pascal Beintus (b. 1966), Nicola Vicentino (b. 1511), Anthony Philip Heinrich (b. 1781), Claude T. Smith (b. 1932), Valery Saparov (b. 1947), Peng-Peng Gong (b. 1992), Thomas Enhco (b. 1988), Carlo Boccadoro (b. 1963), Eino Tamberg (b. 1930), He Zhanhao (b. 1933), Nikolai Rakov (b. 1908), William Mathias (b. 1934), Jesus Guridi (b. 1886), Edmundo Villani-Cortes (b. 1930), Alexei Machavariani (b. 1913), Yuzo Toyama (b. 1931), Jeno Hubay (b. 1858), Selim Palmgren (b. 1878), Charles de Beriot (b. 1802), Federico Moreno Torroba (b. 1891), Arthur Benjamin (b. 1893), Mark Isaacs (b. 1958), Ivan Torrent (b. 1978), Ryan Amon (b. 1978), Gerrit Wunder (b. 1978), Piet Swerts (b. 1960), Philip Harper (b. 1973), Ken Steven (b. 1993), Katerina Gimon (b. 1993), Paolo Ugoletti (b. 1956), Michael Schelle (b. 1950), Baptiste Trotignon (b. 1974), Penka Kouneva (b. 1967), Miguel Kertsman (b. 1965), Maciej Zielinski (b. 1971)
  Rediscovered or revisited, and really liked:
  - Yngwie Malmsteen: Rising Force (1984), "Trilogy Suite" (1986), "Leviathan" (1992), "Overture 1622" (1995), Concerto Suite for Electric Guitar and Orchestra (1998), some of Spellbound (2012), some of World on Fire (2016)
  I also listened to a significant portion of the recorded works by each of the (not new-to-me) composers listed below.3 My favorites pieces from them (names linked to playlists) were:
  - Richard Harvey (b. 1953): most of Concerto Antico (1995)
  - Toshiyuki Honda (b. 1957): Metropolis "Metropolis" & "Run" (2001)
  - Nicholas Britell (b. 1980): "Billie Jean King" & "Bobby Riggs" (2017), "The War in Afghanistan" & "The Iraq War Symphony" (2018), "Succession Main Theme" & "Strings con Fuoco" (2019), Don 't Look Up (2021)
  - Tony Banks (b. 1950): "Blade" (2011)
  - Volker Bertelmann (b. 1966): Drowning (2015), some of All Quiet on the Western Front (2022)
  - Abel Korzeniowski (b. 1972): W.E. (2012), Romeo & Juliet (2013), some of Penny Dreadful (2014), "Wayward Sisters" (2016), "Ghost Waltz" (2016), "Maybe We Are Only Two People" (2021), some of Emily (2022)
  - Ibrahim Maalouf (b. 1980): some of Diagnostic (2011), Levantine Symphony No. 1 (2018)
  - Richard Addinsell (b. 1904): "Warsaw Concerto" (1941)
  - Florent Ghys (b. 1979): "Hommage a Kevin Volans" (2007), "Phase parisienne" (2011), "Friday 3PM" & "Thursday Afternoon" (2016)
  - Thomas Ades (b. 1971): Asyla mvt 3 (1997), Dante "The Thieves" & "The Ascent" (2020)
  - Brian Tyler (b. 1972): "Iron Man 3" (2013), "Thor: The Dark World" & "Thor, Son of Odin" (2013), "Formula 1 Theme" (2018)
  - Jean-Michel Blais (b. 1984): "Nostos" (2016), some of Aubades (2022)
  - Poppy Ackroyd (b. 1982): "Light" (2018)
  - Motoi Sakuraba (b. 1965): "Gwynevere, Princess of Sunlight" (2011), "Sinh, the Slumbering Dragon" (2014)
  - Giacomo Puccini (b. 1858): "O mio babbino caro" (1918), "Nessun dorma" (1926)
  - Tyondai Braxton (b. 1978): "The Violent Light Through Falling Shards" (2005), Central Market (2009)
  - Basil Poledouris (b. 1945): some of Conan the Barbarian (1982), Sword and Sorcery Spectacular (1983), "Hymn to Red October" (1990), Quigley Down Under "Main Title" & "The Fight" (1990), "The Tradition of the Games" (1996)
  - Plus the following composers for which I didn't "strongly like" any of their pieces I listened to: John Luther Adams (b. 1953), Somei Satoh (b. 1947), Jeroen van Veen (b. 1969), Lepo Sumera (b. 1950), Urmas Sisask (b. 1960), Orlando Gough (b. 1953), Tarik O'Regan (b. 1978), Sebastian Fagerlund (b. 1972), Christopher Cerrone (b. 1984), Jorg Widmann (b. 1973), Rick Wakeman (b. 1949), Laurie Anderson (b. 1947), Kelly-Marie Murphy (b. 1964), Esa-Pekka Salonen (b. 1958), Goran Bregovic (b. 1950), Steven Mackey (b. 1956), Krzysztof Penderecki (b. 1933), Michael Thomas Foumai (b. 1987), Jon Gibson (b. 1940), Charles Ives (b. 1874), Arthur Honegger (b. 1892), Frederick Delius (b. 1862), Fredrik Hogberg (b. 1971)
  Movies/TV
  
  Ones I "really liked" (no star), or "loved" (star):
  - Various: It 's Always Sunny in Philadelphia, season 15 (2021)
  - Various: The Great , season 1 (2020) ★
  - Various: The Great , seasons 2-3 (2021-2023)
  - Nash Edgerton: Mr. Inbetween , seasons 1-3 (2018-2021)
  - Yorgos Lanthimos: Bugonia (2025) ★
  - Drew Hancock: Companion (2025)
  - Josh Safdie: Marty Supreme (2025) ★
  - George Miller: Furiosa: A Mad Max Saga (2024) ★
  - Weronika Tofilska & Josephine Bornebusch: Baby Reindeer (2024)
  - Tim Kirkby & Harry Bradbeer: Fleabag , seasons 1-2 (2016-2019)
  - Nathan Fielder: The Rehearsal , seasons 1-2 (2022-2025) ★
  - David Zellner & Nathan Zellner: The Curse (2024) ★
  - John Wilson: How To with John Wilson , seasons 1-2 (2020-2021)
  Games
  
  All games I finished or decided to stop playing:
  - [none]
  Standup comedy
  - Ricky Gervais: Humanity (2018), SuperNature (2022)
  - Ronny Chieng: Asian Comedian Destroys America (2019)
  - Tom Papa: You 're Doing Great (2020)
  - Julia Sweeney: God Said Ha! (1995)
  - Doug Stanhope: The Great White Stanhope (1998), Oslo: Burning the Bridge to Nowhere (2011)
  - Joe List: This Year 's Material (2022)
  - Romesh Ranganathan: Irrational (2016), The Cynic (2025)
  - Ray Romano: Live at Carnegie Hall (2001)
  - Ari Shaffir: America 's Sweetheart (2025)
  - Dustin Nickerson: 30 Isn 't Old, But It Is Almost Old (2024)
  - Michelle Wolf: Joke Show (2019)
  - Phoebe Waller-Bridge: Fleabag (2019)
  - Mike Birbiglia: My Girlfriend 's Boyfriend (2013)
  - Louis CK: Oh My God (2013), Live at the Comedy Store (2015), Back to the Garden (2023)
  - Nate Bargatze: The Greatest Average American (2021)
  - Elon Gold: Chosen and Taken (2014)
  - Ken Kirkman: Just Keep Livin? (2017)
  - Patton Oswalt: No Reason to Complain (2004)
  - Dan Soder: On the Road (2024)
  - Dylan Moran: Monster (2004)
  - Mark Normand: Still Got It (2014), Soup to Nuts (2023)
  - Phil Hanley: Ooh La La (2022)
  - Rachel Feinstein: Big Guy (2024)
  - Nick Mullen: The Year of the Dragon (2023)
  - Simon Amstell: Numb (2012)
  - Ismo: Hello (2026)
  Books
  
  I post book ratings and reviews to my Goodreads account instead of here.
  1. A remix of Mozart's "Lacrimosa" from K. 626.
  2. The pieces I listened to for each composer were: Davis, Brouwer, Paus (plus a few film scores), Jusid (plus a few film scores), Martynov, Podgaits, Beffa, Waksman, Tanguy, Holloway, Seabourne, Sowash, Muller, Ducros, Roustom, Estacio, Franssens, Galliano, Beeftink, Palomo, Igudesman, Clarke, Peck, D'Addona, Aranda, Lias, Pearce, Manookian, Montero, Linkola, Rosauro, Pigovat, Breiner, Appermont, Merula, Demutsky, Hancock (plus several film/TV scores), Desenne, Freiberg, Grau, Cesarini, Kassia, Comitas, Yared, Lau, Jiang, Tjeknavorian, Marhulets, Glick, Ben-Amots, Dresher, Pina, Gavrilin, Kako (plus some TV/film scores and jazz albums), Praulins, Pavlova, Gelgotas, Benzecry, Wada (plus a few film/TV scores), Elizondo, Tate, Hart, Cochran, Contreras, Aho, Puckett, Leon, Debski (plus some film scores), Richter, Soler, Poelman, Mestrovic, Azarashvili, Spanoudakis, Kabardokov, Deleruyelle, Amano (plus several film/TV scores), Velazquez, Rodriguez, Abril (plus several film/TV scores), Alarcon, Schneider, Carr, Houben, Sumaatmadja, Cayabyab, Kebede, Pejman, Atilla, Bestybayev, Onovwerosuoke, Dhamabutra, Okoye, Tamusuza, Onyeji, Vu, Nguyen, Entezami (plus a few film scores), Sun, Isikozlu, Huntrakul, Toledo, Mugambi, Marko, Zumaque, Pinzon, Agudelo, Osman, Dada, Dobrogosz, Howard, Grgin, Karaindrou (plus lots more music for films and plays), Gevorgyan, Tristano, Arnesen, Desyatnikov, Abdulrasol, AlHaj, several film/TV/videogame scores by Iwashiro, Garrop, Hamelin, Otero, Rybnikov, all the Dragon Quest symphonic suites by Sugiyama, Jager, Vahi, Douglas, Mustonen, Peskanov, Reade, Ma, Romero, Kazhlayev, Cosma (plus several film/TV scores), Stafylakis, Roukens, Schnelzer, Mower, Lee, Bonney, Meijering, Brostrom, Scott, Doga (plus several film scores and Film Music Vols. 1-4), Tuur, Ho, Ito, Coleman, Chapela, Visconti, Gander, Reverberi, Copeland (plus a few film scores), Harrison, Maneein (plus a few metal albums), Wallace, Kolonovits, Campo, Dubugnon, Pritsker, Akhunov, Andersson, Batagov, Blake (plus several film scores), several film/TV/videogame scores by Shiina, Rabinovitch-Barakovsky, Jalbert, Helbig, Paterson, Stanhope, Kulenty, Weinberg, Babajanian, Eshpai, Tsintsadze, Akutagawa (plus several film scores), Frolov, Khrennikov, Lyadov, Galindo, Papandopulo, White, Bowen, Larsson, Carwithen (plus Film Music), Wiren, Piston, Gnattali, Perkinson, Auerbach, Howard, Frances-Hoad, Safaian, Grime, Faco, Hardy, Rehnqvist, Bodrov, Tarkiainen, Thomas, Benjamin, Kurth, Zupko, Schmidt, Pulkkis, Prior, Lenaerts, Kurbatov, Nazaykinskaya, Day, El-Khoury, Valencia, Martinez Gallego, Atakoglu, Szentpali, Mozdzer, Koh, A. Tchaikovsky, Lindberg, Bronner, Goto, Valero-Castells, Romberg, Chilcott, Allevi (plus a few albums of piano music), Herdzin, Swearingen, Azmeh, Bresnick, Aagaard-Nilsen, Flores, Cusson, Miranda, O. Martinez, Stamp, Taruya, DiLorenzo, Martin, Li, Silverman, several film/game soundtracks by Otani, Wang I-Yu, Eotvos, Thile, Carrara, Staniland, Evangelista, Goulet, Hylkila, Heath, Jarvi, Fukuda, Balakirev, Shohat, several albums by Warner, Lee, Lorenz, Huillet, O'Loughlin, Runestad, Hakim, Rivas Dominguez, Campogrande, Alonso-Crespo, Tarrodi, Cutler, Chin, Oscher, Wang Jianmin, Lopez-Gavilan, Palmeri, Jones, Ugurlu, Fang, Valor Llorens, Ruehr, Hirose, Mullor Grau, Pusceddu, several film scores by Keeravani, Pascual Vilaplana, Chindamo, Christl, Cassidy, Mangani, various soundtracks by Takanashi, Pujol, Galbraith, Dubra, Sung, Vitier, Aparicio-Barberán, Harle, Suñer-Oriola, Higgins, García i Soler, Borisova-Ollas, Amar (plus several film/TV scores), Stark, Deac, Zhurbin, Mertens, Montero, Majkusiak, Rob Smith, Etezady, Bednar, Noizgenie, Wings of Fates, Gomez, Kreisler, Marino, L'Estrange, Lens, Lago, Einhorn (plus a few film scores), Burki, Maric, Honstein, Karlsson, Halley, Fukushima, Batik, George, Ghidoni, Hamilton, Dobson, Suzuki, Saucedo, Chinesta, Fung, Zimmerli, Sigurosson (plus a few film scores and non-classical albums), Glyn, Nickel, Alyamani, Simic, Wang Chenwei, Amaya, Cervo, Corte-Real, Colomer, Kakhidze, Cupeiro, Tormis, Koshkin, Gamboa, Tura, Castellanos, Chung, Kalvarsky, Chen Gang, Carmichael, Bibergan, Camilleri, Dupertuis, Copley, Andric, Naqvi, Bok, Balci, Angulo, Tyzik, Mashima, Shakhidi, Molla Albero, Rubtsov, Ortolano, Marthinsen, Litvinovsky, Newbold, Franzetti, various albums by Martikainen, Blankenburg, Dombrowski, Fiumara, D'hoe, Trotta, Coleman, Alfeyev, Guerreiro, Marques, Wittrock, Ceunen, Santiago Jacome, Ramírez Gomez, Ledda, Resanovic, Guerra, Raats, Rousselot, Navok, Vinao, Wolfgang, Pilsner, Blesa Lull, Fanshawe, Papoulis, Gu, Khumalo, van Dijk, Sibisi, Quinto Serna, Beintus, Vicentino, Heinrich, Claude T. Smith, Davidson, Saparov, Lopez-Gavilan, Hurnik, Ellisor, Gong, Enhco, Boccadoro, Tamberg, Rantala (plus several jazz albums), He, Rakov, Mathias, Guridi, Villani-Cortes, Machavariani, Toyama, Hubay, Palmgren, Beriot, Moreno Torroba, Benjamin, Tormo Munoz, Isaacs, Janssen, Standridge, a few albums by Torrent, a few albums and film/videogame scores by Amon, Wunder, Shortell, Swerts, Harper, Steven, Gimon, Law, Ugoletti, Geiss, Schelle, Trotignon, Kouneva (plus some film/TV/videogame scores), Kertsman, Zielinski, Dompierre, Pawlik (plus a few jazz albums), Needham.
  3. The pieces I listened to for each composer were: Harvey (plus a few film/TV scores), Honda, Adams, several film/TV scores by Britell, Banks, Bertelmann (plus several film/TV scores and Hauschka albums), Satoh, Veen, several film/TV scores by Korzeniowski, Maalouf (plus several jazz and soundtrack albums), Sumera, Sisask, Addinsell (plus some film music), Gough, Ghys, O'Regan, Fagerlund, Cerrone, Widmann, Wakeman, Anderson, Murphy, Tyler, Salonen, Bregovic (plus several film scores and a few other albums), Blais, Ackroyd, several videogame soundtracks by Sakuraba, Mackey, Puccini, Penderecki, Foumai, Gibson, Ives, Braxton, Honegger, Delius, Hogberg.
22. 🔗 r/Yorkshire I took many photos on my trip there last year but this is the one I find myself returning to the most rss
  
  | Take a guess where! Also thought I’d add a photo of a rather charming fellow I encountered submitted by /u/one-tea27
  [link] [comments]
  ---|---
23. 🔗 r/reverseengineering I wrote a custom decompiler for the bytecode used by Naughty Dog in the The Last of Us & Uncharted games rss
  
  submitted by /u/CMDR_DeepQuantum
  [link] [comments]
24. 🔗 mhx/dwarfs dwarfs-0.15.3 release
  Bug fixes
  - The 0.15.2 release did not include the legacy FUSE v2 driver binaries (dwarfs2) in the static release tarballs.
  - The op_readlink implementation is now guaranteed to terminate the returned string, as required by the FUSE specification.
  Build
  - Warning supressions for (newer) GCC warnings triggered warnings on older GCC versions. These have been fixed.
  Other
  - Some automatic code refactoring from clang-tidy was applied and some minor issues were fixed in the process.
  Full Changelog : v0.15.2...v0.15.3
  
  SHA-256 Checksums
```
70edc89104233aa8afe7548c4b83c97625baf44c34f625fa99deff4b4b01f89f  dwarfs-0.15.3-Linux-aarch64.tar.xz
40c97466c7f8bd6c031ddc3adf3b5a4c90efbccbf1b734e24bf00c8cbf7f8413  dwarfs-0.15.3-Linux-arm.tar.xz
07eb788cfc9cee51e80f319a95591d92510211ac12fcc08e58231903f5e9d835  dwarfs-0.15.3-Linux-i386.tar.xz
10dd05063a8ae4732f49dbb61abb9dbd1ff9d759a9f8ff88a39ecd4251b12660  dwarfs-0.15.3-Linux-loongarch64.tar.xz
b975fa2e0388ccd81b586b766cf30d4c7550a740013394f1a3eb60b66d754036  dwarfs-0.15.3-Linux-ppc64le.tar.xz
e90b19f10fcb7b9c3f0951032f878ed1501d853b393f0cbf2c47f310c9221442  dwarfs-0.15.3-Linux-ppc64.tar.xz
bd53abaf33983401635fc1d1e27565b9dd7aa3f21aa1dd8168115608658fa951  dwarfs-0.15.3-Linux-riscv64.tar.xz
6cc901e63f7f7c7f31f8b11e31a9390f0f03a2199efebefdee4d05c7bd45935c  dwarfs-0.15.3-Linux-s390x.tar.xz
2dba61946786ec563c96783f719316199eeb55a4cbde1436e1b5796f28494fa8  dwarfs-0.15.3-Linux-x86_64.tar.xz
2a9c6b7cb2841f3c7b75839da9326724a2817e4467b20e79e3e24c3eefc13eca  dwarfs-0.15.3.tar.xz
24b3654c6353c4253605d13361c3187b08d38c5844ea3e67145ad0f694a4bdc8  dwarfs-0.15.3-Windows-AMD64.7z
e51b8658ffdfacf8fbe232c4425c58a3cc22e4ad8802494d1e6e940106758222  dwarfs-fuse-extract-0.15.3-Linux-aarch64
9b1f82d9b9fcf93909ea0fc97ad0439f9521120d145d6a43b2ef759511ae259d  dwarfs-fuse-extract-0.15.3-Linux-aarch64.upx
a5c9e9ab2f1b8446f3162569dd5b6738643f117391a729456cc244cc91dae6ce  dwarfs-fuse-extract-0.15.3-Linux-arm
8fbc03a7aa43b3e7a5bce862e41407feb349018a22941db4819cf6fd21e53571  dwarfs-fuse-extract-0.15.3-Linux-arm.upx
7a733919ad311d9c2418e4da08905d61a78d55518998531273b4375ec213a82f  dwarfs-fuse-extract-0.15.3-Linux-i386
e8d79bb1e9f56b7811ed9288449f724700b8bf7fc49063a6e1e42e07cd272849  dwarfs-fuse-extract-0.15.3-Linux-i386.upx
f1ea878bb3e01bb61ad998d3a08f15d4ac43a43a03a877a383697612f50189c9  dwarfs-fuse-extract-0.15.3-Linux-loongarch64
2594e3d37a3cf3cf278e74a04e08a343c3c939f7545e01d66e4054e2af916447  dwarfs-fuse-extract-0.15.3-Linux-ppc64
87a9fafe6b926668acaa63bf4a6542375c5c8e330426d2992b37785a21c6642e  dwarfs-fuse-extract-0.15.3-Linux-ppc64le
a4ef6a576e27486123388c5a4426d84621f911890ebe1d0039c22b4910f3097b  dwarfs-fuse-extract-0.15.3-Linux-riscv64
4f095dbc965f875645ac99c09b69254a88dabb6f767581c4463799879ee1046d  dwarfs-fuse-extract-0.15.3-Linux-riscv64.upx
374e2a4153800818017534bbb4ed28266ebef4b7912e18af0a6084b6afaf9cc3  dwarfs-fuse-extract-0.15.3-Linux-s390x
6b46fcef644fbc88a8e8235f9aece0be1940d568daa631ff0f71c6c2787f0dfe  dwarfs-fuse-extract-0.15.3-Linux-x86_64
9a17a645c121340b687f3e1ea1f1d350ac4b4de390ee0e75ec82ccd2f95cc963  dwarfs-fuse-extract-0.15.3-Linux-x86_64.upx
87a514821c762371a50dac7a271a6c78af3a23cc0c7cc47571713f8fb6707684  dwarfs-universal-0.15.3-Linux-aarch64
daa98361d4671f2afb644c59065632e8e1bc8f033b0692478e5039852d5d39db  dwarfs-universal-0.15.3-Linux-aarch64.upx
88692a6670bec935eaee69d61a9066f3d0e13591229c784b45e056760bc7c9ca  dwarfs-universal-0.15.3-Linux-arm
c62d47af8becf42bae630839d3d04736b56322f1a6d4fc341ad33ea6cd8a28f2  dwarfs-universal-0.15.3-Linux-arm.upx
abf7897855c5d2d84beb11f845630ac14365de5793ebc605679314c7c375a9ad  dwarfs-universal-0.15.3-Linux-i386
42eabcba8ff64c56931d63a7824d59dd58ad86ee603bbad0944fbcb501f0a78d  dwarfs-universal-0.15.3-Linux-i386.upx
ca2723e432f6b751157c62ef5f6bb4e86e9465f327a1b786ff3f6edbf7bf01c5  dwarfs-universal-0.15.3-Linux-loongarch64
691915391b8e77dd0bd3993f70d0198b2abdef69350d850781d0679a9612d8ce  dwarfs-universal-0.15.3-Linux-ppc64
a37f7f25f0acb898971f0911f655cbe432673a26c340d3c5b3cbfd43e569ebcf  dwarfs-universal-0.15.3-Linux-ppc64le
ad30fdecbc301ae10c14ee1141806d16dabd14400c32f980bda4c5643b78049c  dwarfs-universal-0.15.3-Linux-riscv64
404b334707b865cd5ee6bc8749af335301afe94da2fb2524e46ab6613b783f97  dwarfs-universal-0.15.3-Linux-riscv64.upx
393257fb56de88d219e79496c24f50f57a4dece910a255ed421b894b00c93804  dwarfs-universal-0.15.3-Linux-s390x
30c868737fdf7b4167b35650839bcbce0fd73d203f83702bc0afa7eaa2e1bded  dwarfs-universal-0.15.3-Linux-x86_64
f2d2c33c7f22995abd45601dbd61fdee673727d67069c443828fecd6704c7e7c  dwarfs-universal-0.15.3-Linux-x86_64.upx
0ce305dc4c593f9f30098fdc3aec6367159b8f2f25627cda19c794a9c1378b34  dwarfs-universal-0.15.3-Windows-AMD64.exe
4c0c1ac1bb786e62658bf06502c710047ae2c7a670c707abbb92918caef13de4  dwarfs-universal-small-0.15.3-Linux-aarch64
11cecac8b833dc15c1cf18f148400a0608ff1d56d608f1f8a8466ffc584ee66e  dwarfs-universal-small-0.15.3-Linux-aarch64.upx
064a3f389fe7c815449406f1beefea914ec7ce554171fbc27110ceed87518026  dwarfs-universal-small-0.15.3-Linux-arm
a5f000b76db896cc1cdcd4bf0b588602c6da3238ac5a96581671bce18db525dc  dwarfs-universal-small-0.15.3-Linux-arm.upx
c34ceb2ea5e662d46a3fc8220cec23a2b8f8dee5ac000125e00c30f69a235644  dwarfs-universal-small-0.15.3-Linux-i386
242176ab5768625dc59154445125d41b95cbf8459db890da77c8923e4544199a  dwarfs-universal-small-0.15.3-Linux-i386.upx
98c3d497e030cd5d8bad7525650875417cbc00a911d2b813e754cc440f09676b  dwarfs-universal-small-0.15.3-Linux-loongarch64
ad942bbac4235d3a2ac1e1f54e0b3e8e97630726595279df0687bffaa64300f0  dwarfs-universal-small-0.15.3-Linux-ppc64
b1341c2d3469a96c5c8f4404145bb9af986b8f6a0d8b5f168d0ec528c872c249  dwarfs-universal-small-0.15.3-Linux-ppc64le
e7d05a966ad8a9e469f01b8281ba9680c9fa85912bb5881d50567f935f001602  dwarfs-universal-small-0.15.3-Linux-riscv64
9f3afa8633708a3dbcf6c06b34dd75a6b06c46ac703669c8926154b6eb60a9f2  dwarfs-universal-small-0.15.3-Linux-riscv64.upx
4de99aed5e01bd7b85aac72414e61848917e878103a28d76a7f8caabf013d7d0  dwarfs-universal-small-0.15.3-Linux-s390x
16fc1f7bc8d6034a2101323e31b3e18aebf91ed0b8eb41a10c1d4886968aa25c  dwarfs-universal-small-0.15.3-Linux-x86_64
1b7b64d88a361a4f21679366c802513a927081be263bd87aa805c65c1a20d52b  dwarfs-universal-small-0.15.3-Linux-x86_64.upx
```
25. 🔗 r/reverseengineering Chinese Security Reverse Engineered - Trust Decision Solver (Popmart) rss
  
  submitted by /u/Electrical-Flight570
  [link] [comments]
26. 🔗 r/Yorkshire Inspiration exhibition train’s final tour dates announced. With Hull & Scarborough dates. The latter would be the final one rss
  
  | submitted by /u/CaptainYorkie1
  [link] [comments]
  ---|---
27. 🔗 jellyfin/jellyfin 10.11.7 release
  🚀 Jellyfin Server 10.11.7
  
  We are pleased to announce the latest stable release of Jellyfin, version 10.11.7! This minor release brings several bugfixes to improve your Jellyfin experience. As always, please ensure you take a full backup before upgrading!
  
  WARNING : This release contains several extremely important security fixes. These vulnerabilities will be disclosed in 14 days as per our security policy. Users of all versions prior to 10.11.7 are advised to upgrade immediately.
  
  You can find more details about and discuss this release on our forums.
  
  Changelog (29)
  
  🔒 Security
  - Fix for GHSA-j2hf-x4q5-47j3, by @Shadowghost
  - Fix for GHSA-8fw7-f233-ffr8, by @Shadowghost
  - Fix for GHSA-v2jv-54xj-h76w, by @Shadowghost
  - Fix for GHSA-jh22-fw8w-2v9x, by @Shadowghost
  📈 General Changes
  - Fix CA1810 build error [PR #16522], by @Bond-009
  - Fix Null was not checked before using the H264 profile [PR #16519], by @nyanmisaka
  - Remove -copyts and add -flush_packets 1 to subtitle extraction [PR #16440], by @Molier
  - Fix lint issue [PR #16514], by @theguymadmax
  - Fix nullref ex in font handling [PR #16369], by @Bond-009
  - Fix restore backup metadata location [PR #16425], by @theguymadmax
  - Fix NFO saver using wrong provider ID for collectionnumber [PR #16449], by @theguymadmax
  - Fix readrate options in FFmpeg 8.1 [PR #16423], by @nyanmisaka
  - Apply analyzeduration and probesize for subtitle streams to improve codec parameter detection [PR #16293], by @IceStormNG
  - Fix filter detection in FFmpeg 8.1 [PR #16392], by @nyanmisaka
  - Fix subtitle extraction caching empty files [PR #16257], by @lowbit
  - Fix hls segment length adjustment for remuxed content [PR #16341], by @crimsonspecter
  - Fix broken library subtitle download settings [PR #16204], by @MBR-0001
  - Checkpoint WAL before moving library.db in migration [PR #16253], by @theguymadmax
  - Fix nullref in Season.GetEpisodes when the season is detached from a series [PR #16150], by @dfederm
  - Reattach user data after item removal during library scan [PR #16227], by @dfederm
  - Deduplicate provider IDs during MigrateLibraryDb migration [PR #16226], by @dfederm
  - Skip image checks for empty folders [PR #16231], by @theguymadmax
  - Fix TMDB image URLs missing size parameter [PR #16116], by @saltpi
  - Fix random sort returning duplicate items [PR #16098], by @theguymadmax
  - Fix SessionInfoWebSocketListener not using SessionInfoDto [PR #16109], by @nielsvanvelzen
  - Fix HLS playlist generation for transcodes with fractional framerate [PR #16053], by @IceStormNG
  - Rehydrate cached UserData after reattachment [PR #16071], by @MarcoCoreDuo
  - Fix TMDB crew department mapping [PR #16066], by @theguymadmax
  - Revert hidden directory ignore pattern [PR #16077], by @theguymadmax
28. 🔗 r/reverseengineering Community RecRoom server emulation project rss
  
  submitted by /u/CamelSmall7104
  [link] [comments]
March 31, 2026
1. 🔗 IDA Plugin Updates IDA Plugin Updates on 2026-03-31 rss
  IDA Plugin Updates on 2026-03-31
  
  Activity:
  - capa
    
    d9b05ed5: Sync capa rules submodule
  - chernobog
    
    d0f2b306: docs: Add proper credits and LICENSE for ida-cmake
  - DeepExtractIDA
    
    20f87f03: Fix decompilation failure sentinel filtering and add ASM output gener…
  - Greffe
    
    032bd1da: Merge pull request #49 from Lixhr/46-patch-replace-the-target-with-a-…
    
    e325fa88: Patched target instrs
    
    64713e21: Merge pull request #45 from Lixhr/44-core-compute-the-patched-branchs…
    
    5b7141de: Add and check the overwriting branch
    
    73ac97cf: Modify context to keep raw bytes instead of ascii hex
    
    bfdf7236: Set trampolines adresses
    
    23fccfda: Set trampolines adresses
    
    958e5258: Create the StubFactory related to its target
    
    492b0bb6: Delete the target if an error occurs
    
    3415b846: Clean add mechanism, add subfactory to each target
    
    33df9056: Use shared_ptr on StubsFactory::create
    
    af93f7b6: Set patch_base on program's start
    
    a80df7c2: Set patch_base at start
    
    1ef8682c: Delete old patch logic
    
    6e7c6246: Use the same helper on add and add_direct
    
    f1c89029: Deleted old logic
    
    aaf96d00: Save before breaking change
    
    9e68e300: Update readme
    
    f4b13803: TEST: Support multiple tests batch
  - IDAPluginList
    
    3670d1b7: chore: Auto update IDA plugins (Updated: 19, Cloned: 0, Failed: 0)
2. 🔗 jellyfin/jellyfin 10.11.1 release
  🚀 Jellyfin Server 10.11.1
  
  We are pleased to announce the latest stable release of Jellyfin, version 10.11.1!
  
  This minor release brings several bugfixes to improve your Jellyfin experience.
  
  As always, please ensure you stop your Jellyfin server and take a full backup before upgrading!
  
  You can find more details about and discuss this release on our forums.
  
  Changelog (26)
  
  📈 General Changes
  - Improve symlink handling [PR #15209], by @Shadowghost
  - Fix pagination and sorting for folders [PR #15187], by @Shadowghost
  - Update dependency z440.atl.core to 7.6.0 [PR #15225], by @Bond-009
  - Add season number fallback for OMDB and TMDB plugins [PR #15113], by @ivanjx
  - Skip invalid database migration [PR #15212], by @crobibero
  - Skip directory entry when restoring from backup [PR #15196], by @crobibero
  - Skip extracted files in migration if bad timestamp or no access [PR #15220], by @JJBlue
  - Normalize paths in database queries [PR #15217], by @theguymadmax
  - Only save chapters that are within the runtime of the video file [PR #15176], by @CeruleanRed
  - Filter plugins by id instead of name [PR #15197], by @crobibero
  - Play selected song first with instant mix [PR #15133], by @theguymadmax
  - Fix Has(Imdb/Tmdb/Tvdb)Id checks [PR #15126], by @MBR-0001
  - Skip extracted files in migration if bad timestamp or no access [PR #15112], by @Shadowghost
  - Clean up BackupService [PR #15170], by @crobibero
  - Initialize transcode marker during startup [PR #15194], by @crobibero
  - Make priority class setting more robust [PR #15177], by @gnattu
  - Lower required tmp dir size to 512MiB [PR #15098], by @Bond-009
  - Fix XmlOutputFormatter [PR #15164], by @crobibero
  - Make season paths case-insensitive [PR #15102], by @theguymadmax
  - Fix LiveTV images not saving to database [PR #15083], by @theguymadmax
  - Speed-up trickplay migration [PR #15054], by @Shadowghost
  - Optimize WhereReferencedItemMultipleTypes filtering [PR #15087], by @theguymadmax
  - Fix videos with cropping metadata are probed as anamorphic [PR #15144], by @nyanmisaka
  - Reject stream copy of HDR10+ video if the client does not support HDR10 [PR #15072], by @nyanmisaka
  - Log the message more clear when network manager is not ready [PR #15055], by @gnattu
  - Skip invalid keyframe cache data [PR #15032], by @Shadowghost
3. 🔗 r/Leeds Geese on the canal near kirkstall rss
  
  There are these two beautiful geese on the canal at the moment, Greylag goose - the ones with the orange peaks.
  
  I always tend to pass them round the kirkstall/start of town area of the canal
  
  One of them seems to hate me and keeps hissing at me and chasing me on my bike, is this happening to anyone else? or does this goose just hate me 🥲
  
  I don't know what I've done to piss this goose off but I love him and I didn't know that my 30s would be me being scared of cycling on the canal because of geese 😂
  
  submitted by /u/CommunicationOdd3471
  [link] [comments]
4. 🔗 r/york Beautiful sunset today rss
  
  | submitted by /u/silvergal81
  [link] [comments]
  ---|---
5. 🔗 r/york I want to visit York and can anyone tell me where can I park my motorcycle safely? rss
  
  submitted by /u/Odd_Consequence_3574
  [link] [comments]
6. 🔗 r/LocalLLaMA Claude Code's source just leaked — I extracted its multi-agent orchestration system into an open-source framework that works with any LLM rss
  By now you've probably seen the news: Claude Code's full source code was exposed via source maps. 500K+ lines of TypeScript — the query engine, tool system, coordinator mode, team management, all of it.
  
  I studied the architecture, focused on the multi-agent orchestration layer — the coordinator that breaks goals into tasks, the team system, the message bus, the task scheduler with dependency resolution — and re-implemented these patterns from scratch as a standalone open-source framework.
  
  The result is open-multi-agent. No code was copied — it's a clean re- implementation of the design patterns. Model-agnostic — works with Claude and OpenAI in the same team.
  
  What the architecture reveals → what open-multi-agent implements:
  - Coordinator pattern → auto-decompose a goal into tasks and assign to agents
  - Team / sub-agent pattern → MessageBus + SharedMemory for inter-agent communication
  - Task scheduling → TaskQueue with topological dependency resolution
  - Conversation loop → AgentRunner (the model → tool → model turn cycle)
  - Tool definition → defineTool() with Zod schema validation
  Unlike claude-agent-sdk which spawns a CLI process per agent, this runs entirely in-process. Deploy anywhere — serverless, Docker, CI/CD.
  
  MIT licensed, TypeScript, ~8000 lines.
  
  GitHub: https://github.com/JackChen-me/open-multi-agent
  
  submitted by /u/JackChen02
  [link] [comments]
7. 🔗 r/Yorkshire East coast residents encouraged to get involved in £20m regeneration efforts rss
  
  | submitted by /u/willfiresoon
  [link] [comments]
  ---|---
8. 🔗 sacha chua :: living an awesome life Thinking about Emacs coaching goals with Prot rss
  [2026-03-31 Tue]: Hooray for learning out loud! Prot has already posted his responses.
  
  Following up on Emacs Carnival March 2026: Mistakes and learning to reach out: I want to get better at learning with other people's help, so I'm going to experiment with engaging Prot as an Emacs coach. Our first session is this week. Time to lay the groundwork!
  
  If I meet with Prot twice a month for three months, that's a budget of €60 (~CAD 100), which is a reasonable size for an experiment especially since I still have the budget set aside from the Google Open Source Peer Bonus and lovely folks already donated to cover the costs for EmacsConf. When I schedule something with someone, the accountability makes it easier to get stuff done and out the door. For this, a real person is much better than AI because:
  - I get to take advantage of Prot's very large context window, and he knows stuff about the Emacs, the community, and me that I might not remember to mention
  - He can ask real questions and prod at things that are unclear or contradictory, unlike the confirmation bias of LLMs
  - He might point out things that wouldn't occur to me to ask about
  - It triggers my "I promised someone I'd do this" thing
  - I get to support an individual worth supporting rather than contributing to the concentration of wealth and information in for-profit entities
  My motivations:
  - I want to make better use of my focused time during the rest of the schoolyear. For the next three months, my schedule will be fairly predictable and I'll have regular chunks of focused time. Over the past two months, I've averaged around 10 hours of Emacs-related stuff per week (including 1.5 hours or so for Emacs News). I'm currently thinking about language learning and speech input. EmacsConf is on the horizon and will probably ramp up after September, but I can also think ahead of workflow improvements or ways to collaborate with other people. I might put together an Emacs News Highlights presentation. Also, I'm always looking out for ways to build the community.
    
    Summer break during July and August will shake things up again, but I might be able to find some focused time early morning or evening. I'd like to be in a good position to make the most of those time fragments.
  - I want to improve my Emacs Lisp development workflow and learn more about libraries and techniques that might be useful. I'm beginning to have more time to sharpen the saw and I'm curious about all the cool stuff that I missed or skimmed over the past ten years. What are some useful setups for completion, debugging, navigation, etc.?
    
    Current: I sporadically use the extra awesomeness in seq, pcase, lispy, erefactor, ert, buttercup, and undercover, but not consistently. I'd like to reduce the friction and make these habitual.
    
    Areas of friction / improvement:
    
    writing tests, especially for things that are more interactive
    
    navigating code that might be scattered in literate config files or in Emacs Lisp files
    
    forgetting to restart or to make sure all code is saved; running tests via Emacs batch mode will help, as will package-isolate and restart-emacs
  - I want to improve my workflows for writing, making videos, and streaming. If I get better at sharing what I'm working on, I might be able to connect with more people and bounce ideas around. Also, accountability might help me nudge this over the threshold. I probably still need to work in stops and starts, so I want to reduce the friction. I'm curious about other people's workflows for sharing. I like joining meetups, but I tend to share stuff only if no one else has anything planned, because I have my blog and my YouTube channel in case I want to share anything with a wider group of people. I just have to actually post things.
    
    Current: ~1.5 Emacs posts a week aside from Emacs News, attending meetups, sporadically adding short video demos to posts
    
    Average number of Emacs-related posts that aren't Emacs News
    
    (let* ((start "2026-02-01") (end "2026-03-31") (posts (my-blog-posts start end (lambda (o) (and (member "emacs" (alist-get 'categories o)) (not (member "emacs-news" (alist-get 'categories o))))))) (count (length posts))) (my-weekly-average count start end))
    
    Goal: 2-3 non-News posts a week, one video a month, one stream or meetup a month; maybe also beyond looking at the numbers, it might be interesting to build more momentum around a topic, set up trails/navigation, cultivate more of a digital garden
    
    Areas of friction / improvement:
    
    Resisting "one more tweak"
    
    Streaming: Still need to get the hang of talking to myself or having half-conversations with chat: can be worked around by scheduling a session with Prot and opening it to the public
    
    Hiding private information or setting up a separate Emacs for demonstration
    
    Harvesting videos/clips/notes afterwards
  - I want to move more of my configuration into files and libraries that other people can reuse, like sachac/learn-lang and sachac/speech-input. I can also separate the function definitions from the configuration in my code so that people can reuse the functions if they want.
    
    Areas of friction / improvement
    
    renaming things when I want to move them to a library
    
    duplicating small functions (ex: simplify string)
    
    figuring out how to make it possible for someone else to start using my stuff
  Starting questions for Prot:
  - Meta: what are people finding useful for coaching and behaviour change, like learning new keyboard shortcuts or workflows?
  - Your literate config exports to individual .el files. I could probably do something similar to separate my functions from my personal config in order to make it easier for people to reuse parts of my config. Is it worth doing so? Do people tell you that they use those private Emacs Lisp files by loading them, or do they mostly rely on your published packages?
  - Does the division into multiple .el files work fine if you need to bisect your configuration?
  - Do you have some tweaks to make it easier to jump to function definitions considering a literate configuration?
  - What's your general process for migrating things from your config to a repository or package?
  Could be fun. Let's experiment!
  
  View Org source for this post
  
  You can e-mail me at sacha@sachachua.com.
9. 🔗 r/reverseengineering I reverse engineered the Govee H8630 smart display: UART shell, hardcoded AES keys, and MQTT control. rss
  
  submitted by /u/Dr-Shataaz
  [link] [comments]
10. 🔗 r/Leeds Dog friends rss
  
  Hi guys! Me and my partner have a dog called Nyla she’s a malanois Doberman lurcher cross and she’s very barkey…she’s made a few friends in the apartments we stay in but she doesn’t see them too much…we are trying to control her barking but it’s working very slowly…I want her to have more doggy friends and maybe make friends myself with the owners… she’s genuinely such a loving dog and she doesn’t great with mainly boys we’ve only tried her with one girl and the girl didn’t like her…the problem is just that people seem to be scared of her or scared she’s aggressive because of her bark..she’s never bit anyone or another dog :) anyone with a dog who is friendly wanna make doggy friends?
  
  submitted by /u/ReplyDeep9863
  [link] [comments]
11. 🔗 r/LocalLLaMA Analyzing Claude Code Source Code. Write "WTF" and Anthropic knows. rss
  So I spent some time going through the Claude Code source, expecting a smarter terminal assistant.
  
  What I found instead feels closer to a fully instrumented system that observes how you behave while using it.
  
  Not saying anything shady is going on. But the level of tracking and classification is much deeper than most people probably assume.
  
  Here are the things that stood out.
  
  1. It classifies your language using simple keyword detection
  
  This part surprised me because it’s not “deep AI understanding.”
  
  There are literal keyword lists. Words like:
  - wtf
  - this sucks
  - frustrating
  - shit / fuck / pissed off
  These trigger negative sentiment flags.
  
  Even phrases like “continue”, “go on”, “keep going” are tracked.
  
  It’s basically regex-level classification happening before the model responds.
  
  2. It tracks hesitation during permission prompts
  
  This is where it gets interesting.
  
  When a permission dialog shows up, it doesn’t just log your final decision.
  
  It tracks how you behave:
  - Did you open the feedback box?
  - Did you close it?
  - Did you hit escape without typing anything?
  - Did you type something and then cancel?
  Internal events have names like:
  - tengu_accept_feedback_mode_entered
  - tengu_reject_feedback_mode_entered
  - tengu_permission_request_escape
  It even counts how many times you try to escape.
  
  So it can tell the difference between:
  
  “I clicked no quickly” vs
  “I hesitated, typed something, then rejected”
  
  3. Feedback flow is designed to capture bad experiences
  
  The feedback system is not random.
  
  It triggers based on pacing rules, cooldowns, and probability.
  
  If you mark something as bad:
  - It can prompt you to run /issue
  - It nudges you to share your session transcript
  And if you agree, it can include:
  - main transcript
  - sub-agent transcripts
  - sometimes raw JSONL logs (with redaction, supposedly)
  4. There are hidden trigger words that change behavior
  
  Some commands aren’t obvious unless you read the code.
  
  Examples:
  - ultrathink → increases effort level and changes UI styling
  - ultraplan → kicks off a remote planning mode
  - ultrareview → similar idea for review workflows
  - /btw → spins up a side agent so the main flow continues
  The input box is parsing these live while you type.
  
  5. Telemetry captures a full environment profile
  
  Each session logs quite a lot:
  - session IDs
  - container IDs
  - workspace paths
  - repo hashes
  - runtime/platform details
  - GitHub Actions context
  - remote session IDs
  If certain flags are enabled, it can also log:
  - user prompts
  - tool outputs
  This is way beyond basic usage analytics. It’s a pretty detailed environment fingerprint.
  
  6. MCP command can expose environment data
  
  Running:
```
claude mcp get <name>
```
  can return:
  - server URLs
  - headers
  - OAuth hints
  - full environment blocks (for stdio servers)
  If your env variables include secrets, they can show up in your terminal output.
  
  That’s more of a “be careful” moment than anything else.
  
  7. Internal builds go even deeper
  
  There’s a mode (USER_TYPE=ant) where it collects even more:
  - Kubernetes namespace
  - exact container ID
  - full permission context (paths, sandbox rules, bypasses)
  All of this gets logged under internal telemetry events.
  
  Meaning behavior can be tied back to a very specific deployment environment.
  
  8. Overall takeaway
  
  Putting it all together:
  - Language is classified in real time
  - UI interactions and hesitation are tracked
  - Feedback is actively funneled into reports
  - Hidden commands change behavior
  - Runtime environment is fingerprinted
  It’s not “just a chatbot.”
  
  It’s a highly instrumented system observing how you interact with it.
  
  I’m not claiming anything malicious here.
  
  But once you read the source, it’s clear this is much more observable and measurable than most users would expect.
  
  Most people will never look at this layer.
  
  If you’re using Claude Code regularly, it’s worth knowing what’s happening under the hood.
  
  Curious what others think.
  
  Is this just normal product telemetry at scale, or does it feel like over- instrumentation?
  
  If anyone wants, I can share the cleaned source references I used.
  
  X article for share in case: https://x.com/UsmanReads/status/2039036207431344140?s=20
  
  submitted by /u/QuantumSeeds
  [link] [comments]
12. 🔗 r/reverseengineering dexfinder: A Lightning-fast, Pure-Go Alternative to Android's veridex with N-level Call Tracing & ProGuard Deobfuscation rss
  
  submitted by /u/Designer_Engine7577
  [link] [comments]
13. 🔗 r/reverseengineering I reverse-engineered the WHOOP 4.0 Bluetooth protocol and built a PoC Flutter app. Read /research first! rss
  
  submitted by /u/Abdul_Saheel
  [link] [comments]
14. 🔗 r/reverseengineering your hex editor should color-code bytes rss
  
  submitted by /u/S1monom1
  [link] [comments]
15. 🔗 r/Leeds Breaking News, Yorkshire Buses closing up shop at 8pm tonight rss
  
  Yorkshire Buses who run the following routes:
  
  1 (Leeds BS to Wakefield Power Par)
  
  30 (Horsfroth to Pudsey)
  
  51 (Doncaster to Norton on Sundays/BH)
  
  61 (St James Hospital to South Leeds Stadium)
  
  61A (St James Hospital to Cross Green/Hunslet)
  
  116 (Leeds to Wakefield via Osset)
  
  118 (White Rose Centre to Wakefield, limited service)
  
  212 (Dewsbury to Wakefield)
  
  https://bustimes.org/operators/yorkshire-travel-group
  
  Will be closing up shop at 8pm tonight
  
  submitted by /u/CaptainYorkie1
  [link] [comments]
16. 🔗 r/Yorkshire What things are iconically yorkshire? rss
  
  For my scout unit (going to the world scout jamboree) we are collaborating with the other Yorkshire groups to make our badges a Yorkshire rose, and there is 4 groups and a competition for the 5th petals design, so what should i put on that is iconically yorkshire?
  
  submitted by /u/Alarmed_Leg9757
  [link] [comments]
17. 🔗 r/LocalLLaMA Just a helpful open-source contributor rss
  
  | submitted by /u/MagicZhang
  [link] [comments]
  ---|---
18. 🔗 r/LocalLLaMA How it started vs How it's going rss
  
  | Unrelated, simple command to download a specific version archive of npm package: npm pack @anthropic-ai/claude-code@2.1.88 submitted by /u/HornyGooner4401
  [link] [comments]
  ---|---
19. 🔗 r/Yorkshire The March Hare rss
  
  submitted by /u/aspiranthighlander
  [link] [comments]
20. 🔗 @binaryninja@infosec.exchange Join [@mr_phrazer](https://infosec.exchange/@mr_phrazer) with us on Thursday mastodon
  
  Join @mr_phrazer with us on Thursday @4pm ET to pit machine versus machine!
  
  We'll be comparing LLM options for both assisted and fully-automatic reverse engineering, including different CLI interfaces, MCP servers, plugins, and agents.
  
  Get notified so you don't miss who comes out on top of reversing's biggest battle yet: https://www.youtube.com/live/TBqBpaqecMA
21. 🔗 r/reverseengineering [Challenge] Ropper and ROPgadget are blind to this standard binary. Can you build a 48-byte ROP chain without using my tool, LCSAJdump? rss
  
  submitted by /u/LCSAJdump
  [link] [comments]
22. 🔗 r/reverseengineering Quick write-up: TLS callbacks in a real malware sample (Rust runtime initialization) rss
  
  submitted by /u/MalRE429
  [link] [comments]
23. 🔗 r/Yorkshire North Yorkshire doing what it does best. Is there a better harbor view in the UK? rss
  
  | submitted by /u/UnpaidInternVibes
  [link] [comments]
  ---|---
24. 🔗 r/Harrogate Light bulbs recycling rss
  
  Does anyone know of any stores that have a bin for recycling light bulbs? I don't drive so going all the way to the household waste recycling centre isn't the most convenient for me.
  
  thanks!
  
  submitted by /u/jaf_1987
  [link] [comments]
25. 🔗 r/wiesbaden Moved to Wiesbaden rss
  
  Hi all, my Family just moved here a week ago and I was curious on what we could do with our 1 year old, best restaurants, bakeries, etc. if anyone has any in mind :)
  
  submitted by /u/daddyciwa
  [link] [comments]
26. 🔗 r/york Driving instructor recommendations? rss
  
  Does anyone know of any good driving instructors in York with availability in the next few months? Nobody I've contacted even has room on a waiting list!
  
  I'd be fine with manual or automatic, I can't afford to be picky at this point. Bonus points if they're able to be flexible with lesson times too as my work pattern makes it hard to commit to the same time slot every week.
  
  submitted by /u/esper_wing
  [link] [comments]
27. 🔗 r/Yorkshire The Tiled Hall Cafe, Leeds Art Gallery rss
  
  submitted by /u/Yorkshire-List
  [link] [comments]
28. 🔗 r/Leeds The Tiled Hall Cafe rss
  
  Surely one of the prettiest places to enjoy a coffee and a cake in Leeds – the mosaic ceiling is stunning!
  
  You'll find it inside Leeds Art Gallery if you haven't been already.
  
  submitted by /u/Yorkshire-List
  [link] [comments]
29. 🔗 huggingface/candle 0.10.0 release
  
  v0.10.0
30. 🔗 r/Leeds Potential Money Saving Trick (Leeds to London Commute) rss
  I have been commuting between Leeds and London for the past 8-9 months, ever since I relocated. However, every time I commuted, the cost of a return ticket with a railcard was a staggering £60 to £70.
  
  This is where I applied a bit of Logic and Maths to determine whether there is a way to get to London at a lower cost. Below is what I do nowadays:
  - Purchase Norther Line or LNER ticket from Leeds to Doncaster with railcard which costs me around £5 - £6
  - Purchase Hull Trains or Grand Central line tickets from Doncaster to Kings Cross for a price between £18 - £21
  This has effectively brought down my cost by almost 50% although I must admit that there is an increase in journey time by approx 35 - 40 minutes.
  
  submitted by /u/BondBagri
  [link] [comments]
31. 🔗 r/york York > Whitby - stop along the way? rss
  
  Hello all!
  
  My partner and I live in York and we're driving to Whitby on Friday for the weekend
  
  We've done the trip loads of times but always on public transport (shout out coastliner my fave bus route ever) and we're only recently on the road in a car.
  
  We realised we don't actually know the area that well outside of York & Whitby, and want to break the drive up and explore a bit, does anyone have any recommendations of places we could stop for lunch/a wander/something fun to see on the drive over? Not bothered if it's a bit off the beaten track or a slight detour, any suggestions welcome :)
  
  submitted by /u/throwaway1335927
  [link] [comments]
32. 🔗 r/york Housing rss
  
  where can we look for housing in York? it seems so so limited in the centre or even up clifton way. I'd be ideally after a houseshare as I think living alone would be bad for me but I can't find anything or anyone to hunt with and every lead I have falls apart.
  
  I'd be moving in aug/September (starting a Master's; placement-heavy so happy to live with professionals) and getting genuinely really downtrodden by the whole thing. I've had really bad housemate situations before so I'm careful as is but options are really very limited...
  
  spareroom/rightmove/zoopla/the usual private lettings agents have the odd option but they're HMOs and I don't know anyone in York yet and I'm not rich lol
  
  ETA not against hmos in thr slightest genuinely just don't know anybody and had always been told to sign up to them With people in case other rooms don't get filled. Landlords in ny undergrad city would often ask tenants to make up the missing rent themselves
  
  submitted by /u/4rami4
  [link] [comments]
33. 🔗 r/york Placement accommodation rss
  
  Hello, so i currently live in Carlisle and I might be getting a 12 month placement in York. Does anyone know where i could possibly stay for the 12 months? House shares or even if there are locations that are designed for adult placements/ temp living?
  
  Even cities / areas close would also work!
  
  Also any advice on the good areas and the bad areas of York!
  
  submitted by /u/Nearby_Gift_5994
  [link] [comments]
34. 🔗 r/Harrogate Hoxton North Closure? rss
  
  I’m sorry…what?!?
  
  This place is always packed, I always have to wait for a table to eat, how is this place not a viable business anymore? This makes no sense to me and I’m sad to see them go…
  
  submitted by /u/CyclePrevious9043
  [link] [comments]
35. 🔗 r/LocalLLaMA Claude code source code has been leaked via a map file in their npm registry rss
  
  | From Chaofan Shou on 𝕏 (files): https://x.com/Fried_rice/status/2038894956459290963 submitted by /u/Nunki08
  [link] [comments]
  ---|---
36. 🔗 MetaBrainz MerchBrainz rss
  
  We have added a range of great new MetaBrainz designs to our merch store: https://www.redbubble.com/people/metabrainz/shop
  
  These designs by Monkey, previously only available to MetaBrainz summit attendees, have been lightly modified (summit-specific text removed) for everyday wear. Are many people going to know what you're repping? No. Are the ones that do going to go " DAAAAAAAAAAAAMN IT'S THE BRAINZ YO"? Most definitely!
  
  Note: We don 't print 'em, so these mockups may differ from the final product.
  
  Choose your fighter: synth, bollywood, psychedelic, vaporwave or black metal, as well as the classic logo and unicorn designs. We also dropped a couple of additional designs today. As well as a 'new notes!?' sticker/magnet there is a new "I made 1,ooo edits and all I got was this lousy T-shirt" design, and a 100,000 edit version. Rumour has it there are secret versions of this shirt available for super high-scorers…
  
  Do you have great/fun/stupid ideas for MetaBrainz-themed shirts or other merch? Let us know!
37. 🔗 r/reverseengineering Introducing the Rootkit Techniques Matrix and updates to the Guide rss
  
  submitted by /u/rkhunter_
  [link] [comments]
38. 🔗 Cryptography & Security Newsletter Web PKI Reimagined with Merkle Tree Certificates rss
  
  In the past several years, the world has been busy with the migration to post-quantum cryptography, but you couldn’t hear much of Google's plans when it comes to Web PKI. However, work has been in progress for several years, going back to at least early 2023. In late 2025, joining with other interested parties, Google migrated its work to an IETF working group called PLANTS. Work is now ongoing to refine the design and validate it in collaboration with Cloudflare. Recently, Google published a blog post to officially announce this work and provide further details about its future steps. In short, the core design is baked, and the remainder of 2026 will be spent on validating the core technology. In 2027, Google will bootstrap the next-generation Web PKI.
39. 🔗 r/york Queuing up at the monks cross leisure centre? rss
  
  Saw a massive line of people in line for something. Someone said people had been there since 5am. Anyone know why?
  
  submitted by /u/Valuable_Victory_948
  [link] [comments]
40. 🔗 mhx/dwarfs dwarfs-0.15.2 release
  32-bit glibc Build Fixes and FUSE Driver Cleanup
  
  32-bit native build fixes
  
  (#354)
  
  This release fixes a set of issues that showed up in native 32-bit builds, most notably on openSUSE Tumbleweed with glibc. The most important one was related to sparse file tests that create files larger than 4 GiB: glibc requires _FILE_OFFSET_BITS=64 for 64-bit file operations in that environment, and without it those tests would fail. This was not just a test bug, all the binaries simply could not deal with files larger than 4 GiB in this scenario.
  
  However, this was only an issue for glibc-based 32-bit builds. It did not affect musl-libc-based builds, which is why it went unnoticed for some time. This did not affect the statically linked release binaries, which are using musl-libc.
  
  A few additional 32-bit related issues were also fixed: the formatting code for times and ratios relied too heavily on floating-point arithmetic and turned out not to be deterministic across platforms and compilers. That code has now been rewritten to use integer arithmetic instead, avoiding platform- specific behavior. A bug in the test code itself, which surfaced only with GCC, has been fixed as well.
  
  FUSE driver refactoring
  
  The FUSE drivers (dwarfs, dwarfs2) have gone through a substantial internal cleanup and refactoring pass in this release. This fixes a number of subtle startup and option-handling issues and makes the behavior of the different driver variants much more consistent.
  
  One visible improvement is error reporting for invalid options. For example, if -o image_size=1234 was used instead of the correct -o imagesize=1234, older versions would end up reporting a misleading filesystem loading failure rather than flagging the unknown option directly. That kind of behavior has now been fixed.
  
  Internally, this also removes a great deal of preprocessor-heavy startup logic that had diverged over time across the various FUSE implementations and modes (high-level, low-level, Windows, FUSE v2, and FUSE v3). The resulting code is much easier to follow, more consistent across platforms, and better covered by tests.
  
  Bug fixes
  - The image size was not passed correctly to one instance of the filesystem parser, which caused errors when loading a DwarFS image embedded inside a larger file (for example, a multi-layer file). Thanks to Ruan Formigoni for the pull request fixing this issue.
  - The performance monitor timer for op_lseek in the FUSE driver was not initialized correctly. This could lead to segmentation faults or bus errors due to an uninitialized index into a std::deque. The issue has been fixed, and an additional check has been added to catch similar errors in the future.
  - Native 32-bit glibc builds could fail in tests involving sparse files larger than 4 GiB because _FILE_OFFSET_BITS=64 was required for 64-bit file operations. Additional non-deterministic test failures related to time and ratio formatting were also fixed by rewriting that code to use integer arithmetic instead of floating-point arithmetic. A separate test bug that surfaced only with GCC was fixed as well. Addresses #354.
  - The FUSE drivers (dwarfs, dwarfs2) were refactored to eliminate a number of subtle startup and option-handling issues and to make behavior much more consistent across the various supported FUSE variants.
  - The manual pages shown with --man for all tools unintentionally included the license header from XML comments at the top of the source files. The renderer now ignores those comments.
  Build
  - After benchmarking the latest mimalloc allocator, it turns out to perform mostly on par with jemalloc. It is still less configurable, but it is clearly usable when that extra configurability is not needed.
  - The small universal release binaries are now built with mimalloc instead of jemalloc, reducing their size by about 10%.
  - Older Clang versions, such as those shipped with Ubuntu 22.04, are no longer supported because they cannot use libstdc++'s std::expected implementation. DwarFS can still be built on Ubuntu 22.04 with GCC.
  Test
  - A few particularly slow tests were identified through profiling and have been reworked to run faster while still covering most of the same code paths.
  New Contributors
  - @ruanformigoni made their first contribution in #355
  Full Changelog : v0.15.1...v0.15.2
  
  SHA-256 Checksums
```
f81290d5c4890a274a60a82b801e62110975ca466799e4408ad046bc70695aef  dwarfs-0.15.2-Linux-aarch64.tar.xz
2466659a4e783d1bc794e17215dcdf093fae8e9493ffaa03091a85c8c11369f2  dwarfs-0.15.2-Linux-arm.tar.xz
fd6ed59b7805539c6fc6e6e508344d10479f6587abe1040a1e86997f19b52fa0  dwarfs-0.15.2-Linux-i386.tar.xz
62f5f2bac65232184cb14e7bb7921a38b34440dcd688080eebdcdc512915d3ba  dwarfs-0.15.2-Linux-loongarch64.tar.xz
08e556adeb248a20aec04bf70886146f5e56bd0efc0bbe225aae69d20b25d33e  dwarfs-0.15.2-Linux-ppc64le.tar.xz
1668eca05412c2bd848ad4aa606a61fb2bf48f3cf92aac556149778a713885f2  dwarfs-0.15.2-Linux-ppc64.tar.xz
3110c8f630a4ae65fe16e4e3280f74d34b2c7a8224630e03361ed799819eeb9f  dwarfs-0.15.2-Linux-riscv64.tar.xz
5879d6d1e406a5ddf4dc68d8179540bd797af5d58abe7def9e62c6841221eb95  dwarfs-0.15.2-Linux-s390x.tar.xz
ad9ef4edf2d124b5c8d4540b2298a9b520e15841c68b921192d9bcb83eb69455  dwarfs-0.15.2-Linux-x86_64.tar.xz
6b7edcb2121347e273753d949f72913f006ec12477248384b24c48989ec34995  dwarfs-0.15.2.tar.xz
c34c05e7f65edcfd5f21bc3fed2de90d3f4b8c5b311d3b5ae302ae3ec6fc7161  dwarfs-0.15.2-Windows-AMD64.7z
46d690ecf546539d3229df9e3ad2412a806e4dee95e22c9ea843d934003f21bb  dwarfs-fuse-extract-0.15.2-Linux-aarch64
3d49d59416bcb989504b70bc63ebcbbb5be5c9a049bd432cefeb4620aa0fc3ae  dwarfs-fuse-extract-0.15.2-Linux-aarch64.upx
d6b4f4fc498e48031f7e7bb5ed3297a1272a68465f1803ad599ee486b0d49799  dwarfs-fuse-extract-0.15.2-Linux-arm
c5214353ad9de53a7fbff6aa5adfa65a9b830b694be839d5de1dbec9ff6a12f0  dwarfs-fuse-extract-0.15.2-Linux-arm.upx
5056562a6e12bcb20e7e07aeff0fa31113bae52f6feefd1a79f87d412c8bcd6d  dwarfs-fuse-extract-0.15.2-Linux-i386
92ac91f59581663985250cc0bcad02742c5cf1a5b009925212f97c1a424f69c3  dwarfs-fuse-extract-0.15.2-Linux-i386.upx
ede37a302b6e038f25dc4a35f25d8c9378fb2ae35600ec445a1eec0bf8b9d64c  dwarfs-fuse-extract-0.15.2-Linux-loongarch64
eec1b96f2d19c04aeda2099914e0b905cec6dec98be439f1bfc4f8f31c447554  dwarfs-fuse-extract-0.15.2-Linux-ppc64
983ee30f114bbafdeefc7ca8a79eecffa33c6314b9c516e7183424ec1d75802c  dwarfs-fuse-extract-0.15.2-Linux-ppc64le
fba9d984f3258f5c35e441b2eb468e25baa9f339e6100013c5a2fbb1c6bfcc1e  dwarfs-fuse-extract-0.15.2-Linux-riscv64
a3210163095b118407f6b8bd174d60bdb92a9d3fa70b9cdcb761d39570bd2bbb  dwarfs-fuse-extract-0.15.2-Linux-riscv64.upx
28f9ca8b2c9ccfc3c7e5949ed89b33a24aade539b3e0de40d5d364e0d06b0065  dwarfs-fuse-extract-0.15.2-Linux-s390x
85084aae43406fa8892df1cc24bd6df96948d99e8a35ca4c2873518fef0fa41c  dwarfs-fuse-extract-0.15.2-Linux-x86_64
40d027c79c7be4a5f7701433477f832390c3aaab437ca3bb2e3f0aa0a007d557  dwarfs-fuse-extract-0.15.2-Linux-x86_64.upx
b9c25399e1e4672601c0afbcb44e522af71698ea41691384555abe09776c113e  dwarfs-universal-0.15.2-Linux-aarch64
432a460080765f52b2b6e51ef99ca87bc4ba1cdf8fa9257155cd89d1b20edbc8  dwarfs-universal-0.15.2-Linux-aarch64.upx
114496a88f27af058481d09e4c75a5079ff9567317745fd50ca4ae79eec30070  dwarfs-universal-0.15.2-Linux-arm
23703b2ce7de3a3ed52f1441759f91a10ab654243678a050e98e5fda0d821c05  dwarfs-universal-0.15.2-Linux-arm.upx
35771934f6dc34038624cf99179bcfb4fe707c533e294d4a75cebdc56785cf08  dwarfs-universal-0.15.2-Linux-i386
24d6ae52dc7166d667cabb47b77233f3a2e87848fb7ffc71a1d230aeb54dd5f7  dwarfs-universal-0.15.2-Linux-i386.upx
a3d97d40a2cc1baf70efe5e5509f9537826b13ee27bdf3bf95a2914361d31181  dwarfs-universal-0.15.2-Linux-loongarch64
547650e46dde48abdd5824115e3c39cb66d551e4647383716591ea5bbcfb7f2e  dwarfs-universal-0.15.2-Linux-ppc64
9712e02402f2a2094a565d39ec2bad2a3a43dbc042a18c93035726de4b133c24  dwarfs-universal-0.15.2-Linux-ppc64le
24f53482d4992797b178e9d63156519569168d2ad469c998451670c44362c418  dwarfs-universal-0.15.2-Linux-riscv64
912b7c0205df9c3a3af61e9b5816fd7b83219259db3ecbe9d0761be97335d0c1  dwarfs-universal-0.15.2-Linux-riscv64.upx
13719648b094adf2c86df6dcc1c34f6b414d01f2032ab1c035bcc95e97f7d135  dwarfs-universal-0.15.2-Linux-s390x
7e4d7ed1b4c8d3f1db01d6914e5b8bcba1d1eb69dfaafe06d32214797fb0dd55  dwarfs-universal-0.15.2-Linux-x86_64
3f073cf225f975415da316aacee1825497a981ff7dad654bf50adb9b2592f7bb  dwarfs-universal-0.15.2-Linux-x86_64.upx
af985a17f080dd708f4fe8c6993adfa0a9f2545f96322e86dd4464ec2bcc0838  dwarfs-universal-0.15.2-Windows-AMD64.exe
feb6e82cd37eba74540c20ab4b73f82c5698f37bada15c7869ab976e04792c46  dwarfs-universal-small-0.15.2-Linux-aarch64
622c917795af04b045d070846ef8492f1c033f5722aa2c02549e218bcaaeace3  dwarfs-universal-small-0.15.2-Linux-aarch64.upx
759c66628b384769e9a3bcd5f98feadec3faa5334910e865c57551a44258f817  dwarfs-universal-small-0.15.2-Linux-arm
2b2fb1d586d79eff8024f69ffc805a341323358ef96ea7cbaf06b41fb76e9628  dwarfs-universal-small-0.15.2-Linux-arm.upx
041cd1200eeac5cf6bdd0c8dc922d119390959a4881b70eddf82d7ac79ae8d89  dwarfs-universal-small-0.15.2-Linux-i386
1dee9fc1846b902f544d8fcfaf7299b0381fa5d8345c2e9eb5d581ce73350b86  dwarfs-universal-small-0.15.2-Linux-i386.upx
c41cc39c690bba884077f995233eeeef968e6de20b2814fc4c1836281892ce70  dwarfs-universal-small-0.15.2-Linux-loongarch64
9f45a53288ac79192454aa5c96d90c92d47206a6162516b5d8f7efa6b85128a4  dwarfs-universal-small-0.15.2-Linux-ppc64
8a6d16cc922ba48b17c78964388cd04f5fa39593340a1721453ed3ebc766862c  dwarfs-universal-small-0.15.2-Linux-ppc64le
5f05442e1426ce962a0f319f0e27167943024758f5dd508053683a8cefa261a7  dwarfs-universal-small-0.15.2-Linux-riscv64
b84b860adee190cadd0d54a643d9eb787366320371d67944e3e0aff035a4acb5  dwarfs-universal-small-0.15.2-Linux-riscv64.upx
49cc48c441feb0a96b1685a6919ae361a8ae27e060e7a0ff1d92b8611091edaa  dwarfs-universal-small-0.15.2-Linux-s390x
85f0a2a95c8438a06e1177936ae1e4d9e45cec7876824037776b7866cb19973c  dwarfs-universal-small-0.15.2-Linux-x86_64
ff16901aa36b692a98bacfda58c68c5868ff4dd72babe61b33571165730cf477  dwarfs-universal-small-0.15.2-Linux-x86_64.upx
```
41. 🔗 r/reverseengineering hCAPTCHA Reverse Engineered rss
  
  submitted by /u/Electrical-Flight570
  [link] [comments]
42. 🔗 r/reverseengineering hCAPTCHA Reverse Engineered rss
  
  submitted by /u/Electrical-Flight570
  [link] [comments]
43. 🔗 Servo Blog February in Servo: faster layout, pause and resume scripts, and more! rss
  Servo 0.0.6 includes some exciting new features:
  - < button command> and < button commandfor> (@lukewarlow, #41237)
  - ‘:modal’ selectors on < dialog> (@lukewarlow, #42201)
  - ‘@property’ rules (@yezhizhen, @Loirooriol, #42136, #42858)
  - ‘alignment-baseline’ and ‘baseline-shift’ (@Loirooriol, #42361)
  - ‘Content-Security-Policy: base-uri’ (@WaterWhisperer, #42272)
  - partial support for < iframe loading=lazy> (@TimvdLippe, #41959)
  - partial support for ‘transform-style: preserve-3d’ (@simonwuelker, #42755)
  Plus a bunch of new DOM APIs:
  - most of the Pointer Events API (@webbeef, #41290)
  - the UserActivation API (@stevennovaryo, #42060)
  - import.meta.resolve() (@Gae24, #42506)
  - integrity in < script type=importmap> (@Gae24, #42604)
  - the formData() method on Request (@Taym95, #42041)
  - the alpha property on HTMLInputElement (@simonwuelker, #42293)
  - tabIndex on HTMLElement and SVGElement (@mrobinson, @Loirooriol, #42913)
  - fullscreenElement on Document and ShadowRoot (@onsah, #42401)
  - toJSON() on PerformancePaintTiming (@shubhamg13, #42396)
  - navigator.pdfViewerEnabled (@simonwuelker, #42277)
  - keyPath on IDBIndex (@arihant2math, #42431)
  - createIndex() , deleteIndex() , and index() on IDBObjectStore (@arihant2math, @bulltickr, #38840, #42440, #42443)
  This is a big update, so here’s an outline:
  - Work in progress
    – accessibility, execCommand()
  - Developer tools
    – localhost only by default, Inspector, Console, Debugger
  - servoshell
    – servo:config, F5 to reload
  - Embedding API
    – offline builds, user stylesheets, context menus, gamepad API
  - More on the web platform
    – font fallback, cookies, IndexedDB, First and Largest Contentful Paint
  - Performance and stability
    – about:memory, incremental layout, shared memory
  - Bug fixes
    – Windows arm64, layout, DOM events, shadow DOM
  - Donations
    – how you can help Servo flourish
  Work in progress We’ve started working on accessibility support for web content (@alice, @delan, #42333, #42402), gated by a pref (--pref accessibility_enabled). Each webview will be able to expose its own accessibility tree, which the embedder can then integrate into its own accessibility tree. As part of this work: AccessKit now supports combining accessibility trees with its new “subtree” feature (@DataTriny, @delan, @lukewarlow, @alice, AccessKit/accesskit#655, AccessKit/accesskit#641) egui has been migrated to the new AccessKit API (@delan, @lukewarlow, @lucasmerlin, @DataTriny, emilk/egui#7850) we added a Servo API for activating accessibility features (@delan, @alice, #42336), although this has since become a WebView API We’ve started implementing document.execCommand() (@TimvdLippe, #42621, #42626, #42750), gated by a pref (--pref dom_exec_command_enabled). This feature is also enabled in experimental mode , and together with contenteditable , it’s critical for rich text editing on the web. The work done in February includes: document.queryCommandEnabled() (@TimvdLippe, #42634) document.queryCommandSupported() (@TimvdLippe, #42731) document.queryCommandIndeterm() , queryCommandState() , and queryCommandValue() (@TimvdLippe, #42748) the canonicalize whitespace algorithm – this is used by the ‘delete’, ‘forwardDelete’, and ‘insertText’ commands (@TimvdLippe, #42704) contentEditable on HTMLElement – for execCommand() only, excluding any support for interactive editing (@TimvdLippe, #42633, #42734) Developer tools
  
  DevTools has seen some big improvements in February!
  
  When enabled in servoshell, the DevTools server is more secure by default, listening only on localhost when only a port number is specified (@Narfinger, #42502). You can open the port for remote debugging by passing a full SocketAddr, such as --devtools=[::]:6080 or --devtools=0.0.0.0:6080.
  
  In the Inspector tab, you can now edit DOM attributes , and the DOM tree updates when attributes change (@simonwuelker, #42601, #42785). You can now list the event type and phase of event listeners attached to a DOM node as well (@simonwuelker, #42355).
  
  In the Console tab, objects can now be previewed when passed to console.log() and friends (@simonwuelker, #42296, #42510, #42752), and boolean values are now syntax highlighted (@pralkarz, #42513).
  
  In the Debugger tab, you can now pause and resume script execution, both manually and when breakpoints are hit (@eerii, @atbrakhi, #42599, #42580, #42874). We’ve also started working on other debugger features (@atbrakhi, @eerii, #42306), including stepping execution (@eerii, @atbrakhi, #42844, #42878, #42906), so once again stay tuned!
  
  Servo 0.0.6 showing DevTools debugger setting breakpoints, pausing on those breakpoints, and resuming script execution
  
  servoshell Back in August, we added a servo:preferences page to servoshell that allows you to set some of Servo’s most common preferences at runtime (@jdm, #38159). servoshell now has a servo:config page (@arihant2math, #40324), allowing you to set any preference, even internal ones. Note that preference changes are not yet persistent, and not all prefs take effect when changed at runtime. You can now press F5 to reload the page in servoshell (@Narfinger, #42538), in addition to pressing Ctrl+R or ⌘R. We’ve fixed a regression where the caret stopped being visible in the location bar (@mrobinson, #42470). Embedding API
  
  Servo is now easier to build offline , using the complete source tarball included in each release (@jschwe, #42852). Go to a release on GitHub, then download servo-[version]-src-vendored.tar.gz to get started.
  
  You can now add and remove user stylesheets with UserContentManager::add_stylesheet and remove_stylesheet, and remove user scripts with UserContentManager::remove_script (@mukilan, #42288). Previously user stylesheets were only configurable via servoshell’s --user-stylesheet option.
  
  User stylesheets work a bit differently to userstyles , since they cascade via the user origin, not the author origin. For more details about the tradeoffs, check out Customising the web: browsers as user agents (slides).
  
  Before opening any context menus on behalf of web content, Servo now closes any context menus that were opened by web content (@mrobinson, #42487), to avoid UI problems on some platforms. This is done by calling WebViewDelegate::hide_embedder_control before calling show_embedder_control in those cases.
  
  Input method events from web content now indicate whether or not the virtual keyboard should be shown (@stevennovaryo, @mrobinson, #42467), with the new InputMethodControl::allow_virtual_keyboard method. Generally the virtual keyboard should only be shown when the page has sticky activation.
  
  We’re reworking our gamepad API , with WebViewDelegate::play_gamepad_haptic_effect and stop_gamepad_haptic_effect being replaced by a new API that (as of the end of February at least) is known as GamepadProvider (@atbrakhi, #41568). The old methods are no longer called (#43743), and may be removed at some point.
  
  We now have better diagnostic output when we fail to create an OpenGL context (@mrobinson, #42873), including when the OpenGL versions supported by the device are too old.
  
  Servo::constellation_sender was removed (@jdm, #42389), since it was never useful to embedders.
  
  We’ve also made some changes to Preferences:
  - devtools_server_port is now devtools_server_listen_address, and can now take either a port number (as before) or a full SocketAddr (@Narfinger, #42502)
  - dom_worklet_blockingsleep is now dom_worklet_blockingsleep_enabled (@mukilan, #42897)
  - Removed many unused preferences (@mukilan, #42897) – js_asyncstack, js_discard_system_source, js_dump_stack_on_debuggee_would_run, js_ion_offthread_compilation_enabled, js_mem_gc_allocation_threshold_avoid_interrupt_factor, js_mem_gc_allocation_threshold_factor, js_mem_gc_allocation_threshold_mb, js_mem_gc_decommit_threshold_mb, js_mem_gc_dynamic_heap_growth_enabled, js_mem_gc_dynamic_mark_slice_enabled, js_shared_memory, js_throw_on_asmjs_validation_failure, js_throw_on_debuggee_would_run, js_werror_enabled, and network_mime_sniff
  More on the web platform If you navigate to a video file or audio file as a document , the player now has controls (@webbeef, #42488). Images now rotate according to their EXIF metadata by default (@rayguo17, #42567), like they would once we add support for ‘image-orientation: from-image’. We’re implementing system-font-aware font fallback (@mrobinson, #42466), with support for this on macOS landing this month (@mrobinson, #42776). This allows Servo to render text in scripts that are not covered by web fonts or any of the fonts on Servo’s built-in lists of fallback fonts, as long as they are covered by fonts installed on the system. Servo now supports the newer pointermove , pointerdown , pointerup , and pointercancel events (@webbeef, #41290). The older touchmove , touchstart , touchend , and touchcancel events continue to be supported. The default language in ‘Accept-Language’ and navigator.language is now taken from the $LANG environment variable if present (@webbeef, #41919), rather than always being set to en-US. < input type=color> now supports any CSS color value (@simonwuelker, #42275), including the more complex values like color-mix(). We’ve also landed the colorspace attribute (@simonwuelker, #42279), but only in the web- facing side of Servo for now, not the embedding API or in servoshell. ‘vertical-align’ is now a shorthand for ‘alignment-baseline’ and ‘baseline-shift’ (@Loirooriol, #42361), and scrollParent on HTMLElement is now a function per this recent spec update (@TimurBora, #42689). Cookies are now more conformant (@sebsebmc, #42418, #42427, #42435). ‘Expires’ and ‘Max-Age’ attributes are now handled correctly in ‘Set-Cookie’ headers, get() and getAll() on CookieStore now trim whitespace in cookie names and values, and the behaviour of set() on CookieStore has been improved. < iframe> elements are now more conformant in how load events are fired on the element and its contentWindow (@TimvdLippe, #42254), although there are still some bugs. This has long behaved incorrectly in Servo, and it has historically caused many problems in the Web Platform Tests. IndexedDB is now more conformant in our handling of transactions (@Taym95, #41508, #42732), and when opening and closing connections (@gterzian, @Taym95, #42082, #42669). We’ve started implementing Largest Contentful Paint timings (@shubhamg13, #42024), and we’ve landed a bunch of improvements to how First Contentful Paint timings work in Servo: we now include ‘background-image’ (@shubhamg13, #42569) we now include ‘border-image’ (@shubhamg13, #42581) we now ignore subtrees with ‘opacity: 0’ (@shubhamg13, #42768) we now ignore zero-sized subtrees (@shubhamg13, #42178) we now ignore <iframe> (@shubhamg13, #42498) we now ignore <video> and unless they actually have an image (@shubhamg13, #42411) we now ignore mouse moves when deciding when to stop measuring (@shubhamg13, #41999) new WebSocket() now resolves relative URLs (@webbeef, #42425). requestFullscreen() on Element now requires user activation (@stevennovaryo, #42060). performance.getEntries() now returns PerformanceResourceTiming entries for navigations in <iframe> (@muse254, #42270). When geolocation is enabled (--pref dom_geolocation_enabled), navigator.geolocation.getCurrentPosition() and watchPosition() now support the optional errors argument (@arihant2math, #42295). We now support the ‘-webkit-text-security’ property in CSS (@mrobinson, #42181), which is not specified anywhere but required for MotionMark. Performance and stability
  
  Our about:memory page now knows how to report many new kinds of memory usage , including the DevTools server (@Narfinger, #42478, #42480), WebGL (@sagudev, #42570), localStorage and sessionStorage (@arihant2math, #42484), and some of the memory used by IndexedDB (@arihant2math, #42486). We’ve also started internally tracking the memory usage of the media subsystem (@Narfinger, #42504) and WebXR (@Narfinger, #42505).
  
  Layout has seen a lot of performance work in February, with our main focus being on improving incremental layout of the box tree and fragment tree.
  
  We now have our first truly incremental box tree layout (@mrobinson, @Loirooriol, @lukewarlow, #42700), rather than our previous “dirty roots”-based approach. Depending on how they were damaged, some boxes for floats (as above, #42816), independent formatting contexts (as above, #42783), and their descendants (as above, #42582) can now be reused, and they avoid damaging their parents (as above, #42847). We also destroy boxes with ‘display: none’ earlier in the layout process (as above, #42584).
  
  Incremental fragment tree layout is improving too! Whereas we previously had to decide whether to run fragment tree layout in an “all or nothing” way, we can now reuse cached fragments in independent formatting contexts (@mrobinson, @Loirooriol, @lukewarlow, #42687, #42717, #42871). We can also measure how much work is being done on each layout (as above, #42817).
  
  Servo uses shared memory for many situations where copying data over channels would be too expensive, such as for images and fonts. In multiprocess mode (--multiprocess), we use the operating system to create the shared memory in a way that can be shared with other processes, such as shm_open(3) or CreateFileMappingW, but this consumes resources that can sometimes be exhausted. We only need to use those kinds of shared memory in multiprocess mode, so we’ve reworked Servo to use Arc<Vec<u8>> in single-process mode (@Narfinger, #42083), which should avoid resource exhaustion.
  
  Parsing web pages is complicated: we want pages to render incrementally as they stream in from the network, and we want to prefetch resources, but scripts can call document.write(), which injects markup “on the spot”. This is further complicated if that markup also contains a <script>.
  
  We’ve recently landed some fixes to Servo’s async parser (@simonwuelker, #42882, #42910), which handles these issues more efficiently. This is currently an obscure and somewhat buggy feature (--pref dom_servoparser_async_html_tokenizer_enabled), but if we can get the feature working more reliably (#37418), it could halve the energy Servo spends on parsing, lower latency for pages that don’t use document.write(), and even improve the html5ever API for the ecosystem.
  
  We’ve also landed optimisations for ‘Content-Security-Policy’ (@Narfinger, #42716), IntersectionObserver (@Narfinger, @mrobinson, @stevennovaryo, #42366, #42390), layout queries (@webbeef, #42327), the bfcache (@Narfinger, #42703), loading images (@Narfinger, #42684), and checks for multiprocess mode (@Narfinger, #42782), as well as the interfaces between Servo and SpiderMonkey (@sagudev, #42135, #42576).
  
  We’ve continued our long-running effort to use the Rust type system to make certain kinds of dynamic borrow failures impossible (@Gae24, @pralkarz, @BryanSmith00, @sagudev, @Narfinger, @TimvdLippe, @kkoyung, @TimurBora, @onsah, #42342, #42294, #42370, #42417, #42619, #42616, #42637, #42640, #42662, #42679, #42681, #42665, #42667, #42699, #42712, #42725, #42729, #42726, #42720, #42738, #42737, #42735, #42751, #42805, #42809, #42780, #42820, #42715, #42635, #42880, #42846).
  
  Bug fixes We’ve landed some fixes for issues preventing Servo from being built on Windows arm64 (@dpaoliello, @npiesco, #42371, #42341). Work to enable Windows arm64 as a build platform is ongoing (@npiesco, #42312). < img height> now takes the default from the aspect ratio of the image (@Loirooriol, #42577), rather than using a width of 300px by default. < svg width=0> and < svg height=0> now take the default width and height (respectively) from the aspect ratio of the (@Loirooriol, #42545). We’ve fixed a bug in the result of layout queries , such as getBoundingClientRect(), on inline < svg> (@jdm, @Loirooriol, #42594), and we’ve fixed layout bugs related to ‘display: table-cell’ (@Loirooriol, #42778), ‘display: list-item’ (@Loirooriol, #42825, #42864), ‘inset: auto’ (@Loirooriol, #42586), ‘width: max-content’ (@mrobinson, @Loirooriol, @lukewarlow, #42574), ‘align-self: last baseline’ (@rayguo17, #42724), ‘list-style-image’ (@lukewarlow, #42332), ‘content: ’ (@lukewarlow, #42332), negative ‘margin’ (@Loirooriol, #42889), and ink overflow (@mrobinson, #42403). HTML and CSS bugs: Empty ‘url()’ values making requests when they shouldn’t (@rayguo17, #42622) < template> failing to throw HierarchyRequestError when a DOM API is used to create an invalid hierarchy (@TimvdLippe, #42276) < input> and < textarea> selection behaviour being incorrect when the text contains more than one script (@mrobinson, #42399) < script nonce> validation failing to work correctly in some cases (@dyegoaurelio, #40956) < a target> failing to work correctly after the related <iframe> is removed and a new one added with the same name (@jdm, #42344) < base> not taking effect in some cases, or taking effect when given a data: or javascript: URL (@TimvdLippe, #42255, #42339) JavaScript and DOM bugs: event.target being incorrect on touchmove , touchend , and touchcancel events (@yezhizhen, #42654) touchmove events not being fired when part of a two-finger pinch zoom (@yezhizhen, #42528) touchend events erroneously firing after touchcancel events (@yezhizhen, #42654) assignedNodes() on HTMLSlotElement returning incorrect results after the <slot> was removed from the shadow tree (@rayguo17, #42250) Largest Contentful Paint timings no longer being collected after reloading or navigating (@shubhamg13, #41169) PerformancePaintTiming being exposed to Worker globals when they shouldn’t be (@shubhamg13, #42409) JavaScript modules resolved incorrectly when there are overlapping .imports or .scopes or import maps (@Gae24, #42668, #42630, #42754, #42821) changes to how we trigger garbage collection breaking Speedometer (@sagudev, #42271) WebDriver bugs: Pointer actions and wheel actions behaving incorrectly when devicePixelRatio ≠ 1 (@yezhizhen, #42387, #42628) Wheel actions throwing incorrect exceptions when they are missing properties (@yezhizhen, #42745) pointerMove actions with non-zero duration failing to interleave with other actions (@yezhizhen, #42289) We’ve fixed crashes in DevTools , in the Inspector tab (@eerii, @mrobinson, #42330), when exiting Servo while DevTools is connected (@simonwuelker, #42543), when setting breakpoints (@atbrakhi, #42810), and after clients disconnect (@simonwuelker, #42583). We’ve fixed crashes in layout , when using ‘background-repeat: round’ (@mrobinson, #42303), when using ‘list-style- image’ or ‘content: ’ (@lukewarlow, #42332), when calling elementFromPoint() on Document (@mrobinson, @Loirooriol, @lukewarlow, #42822), and when handling layout queries like getBoundingClientRect() on inline <svg> (@jdm, @Loirooriol, #42594). We’ve fixed crashes related to stylesheets , when removing stylesheets from the DOM (@TimvdLippe, #42273), when changing the href of a (@TimvdLippe, #42481), and when loading stylesheets with --layout-threads=1 (@mrobinson, @Loirooriol, @lukewarlow, #42685). We’ve also fixed crashes when using multitouch input (@yezhizhen, #42350), when using MediaStreamAudioSourceNode (@mrobinson, #42914), when calling add() on HTMLOptionsCollection (@mrobinson, #42263), when calling elementFromPoint() on Document or ShadowRoot(), when we fail to open a database for IndexedDB (@jdm, @mrobinson, #42444), and when certain pages are run with a mozjs debug build (@Gae24, #42428). Donations
  
  Thanks again for your generous support! We are now receiving 6985 USD/month (−0.4% from January) in recurring donations. This helps us cover the cost of our speedy CI and benchmarking servers, one of our latest Outreachy interns , and funding maintainer work that helps more people contribute to Servo.
  
  Servo is also on thanks.dev, and already 32 GitHub users (–1 from January) that depend on Servo are sponsoring us there. If you use Servo libraries like url, html5ever, selectors, or cssparser, signing up for thanks.dev could be a good way for you (or your employer) to give back to the community.
  
  We now have sponsorship tiers that allow you or your organisation to donate to the Servo project with public acknowlegement of your support. If you’re interested in this kind of sponsorship, please contact us at join@servo.org.
  
  6985 USD/month
  
  10000
  
  Use of donations is decided transparently via the Technical Steering Committee’s public funding request process , and active proposals are tracked in servo/project#187. For more details, head to our Sponsorship page.
44. 🔗 exe.dev Prompt engineering is dead, but Claude still tries rss
  A year ago, Claude was better at prompting than I was. Not any more.
  
  Coding agents have gotten dramatically better. Good prompting used to require carefully calibrated instructions and harnesses. Now a good prompt includes goals, context, and maybe some preferences and operational details.
  
  LLMs used to be lackadaisical about following rules. No longer. If you tell them exactly what to do, they will do exactly that. That can be helpful! But in the real, messy world, it's extraordinarily difficult to define in advance a good set of rules. Instead, we constantly exercise judgment. Agents are really good at on-the-fly judgment now. Delegation beats micromanagement.
  
  Most system prompts should be deleted. Most skills should be deleted. Most AGENTS.md should be deleted. It's all getting in the way now; the bitter lesson has come for harnesses.
  
  My personal CLAUDE.md is 3 lines long. Here it is:
  - Do not git push, ever, under any circumstances.
  - Do not hand-edit Go imports. Run goimports -w after every edit.
  - When writing prompts for other agents, convey intent, nuance, and operational details rather than prescriptive instructions—goals are durable, orders are brittle. Trust and delegate over command and control.
  I look forward to deleting the goimports line in the near future.
  
  I'd also love to nix the last line, which unfortunately doesn't even work completely. Claude doesn't understand yet that we don't live in 2025.
  
  When Claude barks orders like a drill sergeant, it erases the underlying purpose. Every layer of subagents loses ever more fidelity, like a game of LLM telephone.
  
  The thing is: agents prompt agents all the time. Agents help people write skills. Agents invoke subagents. Agents write scripts that run agents.
  
  Shelley, the exe.dev coding agent, has an orchestrator mode. It works around this form of context collapse by giving all subagents access to a SQLite database containing the entire set of all conversations. Subagents refer back to the user's input as a primary source.