🏡

to read (pdf)

generated: March 25, 2026 at 15:22:57

March 25, 2026
1. 🔗 Anton Zhiyanov Porting Go's io 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. So I started with the standard library packages that had the fewest dependencies, and one of them was the io package. This post is about how that went.
  
  io package • Slices • Multiple returns • Errors • Interfaces • Type assertion • Specialized readers • Copy • Wrapping up
  
  The io package
  
  io is one of the core Go packages. It introduces the concepts of readers and writers , which are also common in other programming languages.
  
  In Go, a reader is anything that can read some raw data (bytes) from a source into a slice:
```
type Reader interface {
    Read(p []byte) (n int, err error)
}
```
  A writer is anything that can take some raw data from a slice and write it to a destination:
```
type Writer interface {
    Write(p []byte) (n int, err error)
}
```
  The io package defines many other interfaces, like Seeker and Closer, as well as combinations like ReadWriter and WriteCloser. It also provides several functions, the most well-known being Copy, which copies all data from a source (represented by a reader) to a destination (represented by a writer):
```
func Copy(dst Writer, src Reader) (written int64, err error)
```
  C, of course, doesn't have interfaces. But before I get into that, I had to make several other design decisions.
  
  Slices
  
  In general, a slice is a linear container that holds N elements of type T. Typically, a slice is a view of some underlying data. In Go, a slice consists of a pointer to a block of allocated memory, a length (the number of elements in the slice), and a capacity (the total number of elements that can fit in the backing memory before the runtime needs to re-allocate):
```
type slice struct {
    array unsafe.Pointer
    len   int
    cap   int
}
```
  Interfaces in the io package work with fixed-length slices (readers and writers should never append to a slice), and they only use byte slices. So, the simplest way to represent this in C could be:
```
typedef struct {
    uint8_t* ptr;
    size_t len;
} Bytes;
```
  But since I needed a general-purpose slice type, I decided to do it the Go way instead:
```
typedef struct {
    void* ptr;
    size_t len;
    size_t cap;
} so_Slice;
```
  Plus a bound-checking helper to access slice elements:
```
#define so_at(T, s, i) (*so_at_ptr(T, s, i))
#define so_at_ptr(T, s, i) ({            \
    so_Slice _s_at = (s);                \
    size_t _i = (size_t)(i);             \
    if (_i >= _s_at.len)                 \
        so_panic("index out of bounds"); \
    (T*)_s_at.ptr + _i;                  \
})
```
  Usage example:
```
// go
nums := make([]int, 3)
nums[0] = 11
nums[1] = 22
nums[2] = 33
n1 := nums[1]



// c
so_Slice nums = so_make_slice(int, 3, 3);
so_at(int, nums, 0) = 11;
so_at(int, nums, 1) = 22;
so_at(int, nums, 2) = 33;
so_int n1 = so_at(int, nums, 1);
```
  So far, so good.
  
  Multiple returns
  
  Let's look at the Read method again:
```
Read(p []byte) (n int, err error)
```
  It returns two values: an int and an error. C functions can only return one value, so I needed to figure out how to handle this.
  
  The classic approach would be to pass output parameters by pointer, like read(p, &n, &err) or n = read(p, &err). But that doesn't compose well and looks nothing like Go. Instead, I went with a result struct:
```
typedef union {
    bool as_bool;
    so_int as_int;
    int64_t as_i64;
    so_String as_string;
    so_Slice as_slice;
    void* as_ptr;
    // ... other types
} so_Value;

typedef struct {
    so_Value val;
    so_Error err;
} so_Result;
```
  The so_Value union can store any primitive type, as well as strings, slices, and pointers. The so_Result type combines a value with an error. So, our Read method (let's assume it's just a regular function for now):
```
func Read(p []byte) (n int, err error)
```
  Translates to:
```
so_Result Read(so_Slice p);
```
  And the caller can access the result like this:
```
so_Result res = Read(p);
if (res.err) {
    so_panic(res.err->msg);
}
so_println("read", res.val.as_int, "bytes");
```
  Errors
  
  For the error type itself, I went with a simple pointer to an immutable string:
```
struct so_Error_ {
    const char* msg;
};
typedef struct so_Error_* so_Error;
```
  Plus a constructor macro:
```
#define errors_New(s) (&(struct so_Error_){s})
```
  I wanted to avoid heap allocations as much as possible, so decided not to support dynamic errors. Only sentinel errors are used, and they're defined at the file level like this:
```
so_Error io_EOF = errors_New("EOF");
so_Error io_ErrOffset = errors_New("io: invalid offset");
```
  Errors are compared by pointer identity (==), not by string content — just like sentinel errors in Go. A nil error is a NULL pointer. This keeps error handling cheap and straightforward.
  
  Interfaces
  
  This was the big one. In Go, an interface is a type that specifies a set of methods. Any concrete type that implements those methods satisfies the interface — no explicit declaration needed. In C, there's no such mechanism.
  
  For interfaces, I decided to use "fat" structs with function pointers. That way, Go's io.Reader:
```
type Reader interface {
    Read(p []byte) (n int, err error)
}
```
  Becomes an io_Reader struct in C:
```
typedef struct {
    void* self;
    so_Result (*Read)(void* self, so_Slice p);
} io_Reader;
```
  The self pointer holds the concrete value, and each method becomes a function pointer that takes self as its first argument. This is less efficient than using a static method table, especially if the interface has a lot of methods, but it's simpler. So I decided it was good enough for the first version.
  
  Now functions can work with interfaces without knowing the specific implementation:
```
// ReadFull reads exactly len(buf) bytes from r into buf.
so_Result io_ReadFull(io_Reader r, so_Slice buf) {
    so_int n = 0;
    so_Error err = NULL;
    for (; n < so_len(buf) && err == NULL;) {
        so_Slice curBuf = so_slice(so_byte, buf, n, buf.len);
        so_Result res = r.Read(r.self, curBuf);
        err = res.err;
        n += res.val.as_int;
    }
    // ...
}

// A custom reader.
typedef struct {
    so_Slice b;
} reader;

static so_Result reader_Read(void* self, so_Slice p) {
    // ...
}

int main(void) {
    // We'll read from a string literal.
    so_String str = so_str("hello world");
    reader rdr = (reader){.b = so_string_bytes(str)};

    // Wrap the specific reader into an interface.
    io_Reader r = (io_Reader){
        .self = &rdr,
        .Read = reader_Read,
    };

    // Read the first 4 bytes from the string into a buffer.
    so_Slice buf = so_make_slice(so_byte, 4, 4);
    // ReadFull doesn't care about the specific reader implementation -
    // it could read from a file, the network, or anything else.
    so_Result res = io_ReadFull(r, buf);
}
```
  Calling a method on the interface just goes through the function pointer:
```
// r.Read(buf) becomes:
r.Read(r.self, buf);
```
  Type assertion
  
  Go's interface is more than just a value wrapper with a method table. It also stores type information about the value it holds:
```
type iface struct {
    tab  *itab
    data unsafe.Pointer  // specific value
}

type itab struct {
    Inter *InterfaceType // method table
    Type  *Type          // type information
    // ...
}
```
  Since the runtime knows the exact type inside the interface, it can try to "upgrade" the interface (for example, a regular Reader) to another interface (like WriterTo) using a type assertion :
```
// copyBuffer copies from src to dst using the provided buffer
// until either EOF is reached on src or an error occurs.
func copyBuffer(dst Writer, src Reader, buf []byte) (written int64, err error) {
    // If the reader has a WriteTo method, use it to do the copy.
    if wt, ok := src.(WriterTo); ok {  // try "upgrading" to WriterTo
        return wt.WriteTo(dst)
    }
    // src is not a WriterTo, proceed with the default copy implementation.
```
  The last thing I wanted to do was reinvent Go's dynamic type system in C, so dropping this feature was an easy decision.
  
  There's another kind of type assertion, though — when we unwrap the interface to get the value of a specific type:
```
// Does r (a Reader) hold a pointer to a value of concrete type LimitedReader?
// If true, lr will get the unwrapped pointer.
lr, ok := r.(*LimitedReader)
```
  And this kind of assertion is quite possible in C. All we have to do is compare function pointers:
```
// Are r.Read and LimitedReader_Read the same function?
bool ok = (r.Read == LimitedReader_Read);
if (ok) {
    io_LimitedReader* lr = r.self;
}
```
  If two different types happened to share the same method implementation, this would break. In practice, each concrete type has its own methods, so the function pointer serves as a reliable type tag.
  
  Specialized readers
  
  After I decided on the interface approach, porting the actual io types was pretty easy. For example, LimitedReader wraps a reader and stops with EOF after reading N bytes:
```
type LimitedReader struct {
    R Reader
    N int64
}

func (l *LimitedReader) Read(p []byte) (int, error) {
    if l.N <= 0 {
        return 0, EOF
    }
    if int64(len(p)) > l.N {
        p = p[0:l.N]
    }
    n, err := l.R.Read(p)
    l.N -= int64(n)
    return n, err
}
```
  The logic is straightforward: if there are no bytes left, return EOF. Otherwise, if the buffer is bigger than the remaining size, shorten it. Then, call the underlying reader, and decrease the remaining size.
  
  Here's what the ported C code looks like:
```
typedef struct {
    io_Reader R;
    int64_t N;
} io_LimitedReader;

so_Result io_LimitedReader_Read(void* self, so_Slice p) {
    io_LimitedReader* l = self;
    if (l->N <= 0) {
        return (so_Result){.val.as_int = 0, .err = io_EOF};
    }
    if ((int64_t)(so_len(p)) > l->N) {
        p = so_slice(so_byte, p, 0, l->N);
    }
    so_Result res = l->R.Read(l->R.self, p);
    so_int n = res.val.as_int;
    l->N -= (int64_t)(n);
    return (so_Result){.val.as_int = n, .err = res.err};
}
```
  A bit more verbose, but nothing special. The multiple return values, the interface call with l.R.Read, and the slice handling are all implemented as described in previous sections.
  
  Copy
  
  Copy is where everything comes together. Here's the simplified Go version:
```
// Copy copies from src to dst until either
// EOF is reached on src or an error occurs.
func Copy(dst Writer, src Reader) (written int64, err error) {
    // Allocate a temporary buffer for copying.
    size := 32 * 1024
    buf := make([]byte, size)
    // Copy from src to dst using the buffer.
    for {
        nr, er := src.Read(buf)
        if nr > 0 {
            nw, ew := dst.Write(buf[0:nr])
            written += int64(nw)
            if ew != nil {
                err = ew
                break
            }
        }
        if er != nil {
            if er != EOF {
                err = er
            }
            break
        }
    }
    return written, err
}
```
  In Go, Copy allocates its buffer on the heap with make([]byte, size). I could take a similar approach in C — make Copy take an allocator and use it to create the buffer like this:
```
so_Result io_Copy(mem_Allocator a, io_Writer dst, io_Reader src) {
    so_int size = 32 * 1024;
    so_Slice buf = mem_AllocSlice(so_byte, a, size, size);
    // ...
}
```
  But since this is just a temporary buffer that only exists during the function call, I decided stack allocation was a better choice:
```
so_Result io_Copy(io_Writer dst, io_Reader src) {
    so_int size = 8 * 1024;
    so_Slice buf = so_make_slice(so_byte, size, size);
    // ...
}
```
  so_make_slice allocates memory on a stack with a bounds-checking macro that wraps C's alloca. It moves the stack pointer and gives you a chunk of memory that's automatically freed when the function returns.
  
  People often avoid using alloca because it can cause a stack overflow, but using a bounds-checking wrapper fixes this issue. Another common concern with alloca is that it's not block-scoped — the memory stays allocated until the function exits. However, since we only allocate once, this isn't a problem.
  
  Here's the simplified C version of Copy:
```
so_Result io_Copy(io_Writer dst, io_Reader src) {
    so_int size = 8 * 1024; // smaller buffer, 8 KiB
    so_Slice buf = so_make_slice(so_byte, size, size);
    int64_t written = 0;
    so_Error err = NULL;
    for (;;) {
        so_Result resr = src.Read(src.self, buf);
        so_int nr = resr.val.as_int;
        if (nr > 0) {
            so_Result resw = dst.Write(dst.self, so_slice(so_byte, buf, 0, nr));
            so_int nw = resw.val.as_int;
            written += (int64_t)(nw);
            if (resw.err != NULL) {
                err = resw.err;
                break;
            }
        }
        if (resr.err != NULL) {
            if (resr.err != io_EOF) {
                err = resr.err;
            }
            break;
        }
    }
    return (so_Result){.val.as_i64 = written, .err = err};
}
```
  Here, you can see all the parts from this post working together: a function accepting interfaces, slices passed to interface methods, a result type wrapping multiple return values, error sentinels compared by identity, and a stack-allocated buffer used for the copy.
  
  Wrapping up
  
  Porting Go's io package to C meant solving a few problems: representing slices, handling multiple return values, modeling errors, and implementing interfaces using function pointers. None of this needed anything fancy — just structs, unions, functions, and some macros. The resulting C code is more verbose than Go, but it's structurally similar, easy enough to read, and this approach should work well for other Go packages too.
  
  The io package isn't very useful on its own — it mainly defines interfaces and doesn't provide concrete implementations. So, the next two packages to port were naturally bytes and strings — I'll talk about those in the next post.
  
  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 io package is included, of course.
2. 🔗 r/reverseengineering Announcing ida-mcp 2.0: A Headless MCP Server for IDA Pro rss
  
  submitted by /u/jtsylve
  [link] [comments]
3. 🔗 r/york Does anyone want/need any pallets rss
  
  | Posted on the FB free york page, and thought id also post here, incase people dont have FB 3 pallets, free to collect Tang Hall area submitted by /u/anus-cannon
  [link] [comments]
  ---|---
4. 🔗 HexRaysSA/plugin-repository commits sync repo: +1 release rss
```
sync repo: +1 release

## New releases
- [BinSync](https://github.com/binsync/binsync): 5.13.0
```
5. 🔗 r/Yorkshire Rolls-Royce invests £19.3m in aim to double Rotherham factory output rss
  
  | submitted by /u/willfiresoon
  [link] [comments]
  ---|---
6. 🔗 r/york Best pubs/bars for smokers? (nice beer gardens etc) rss
  
  Going for a meal and a few afternoon drinks to central York with my best friend soon, only thing is he's a very heavy smoker- I pick the wrong place and I don't see him much as I'm sat in,whilst he is always stood outside the front door having his next smoke!
  
  We're both in our 40s, so no clubs or teen hangouts please. Thank you.
  
  submitted by /u/map01302
  [link] [comments]
7. 🔗 r/york Charging Port Cleaning rss
  
  Hi, my steamdeck only charges at certain angles and I think the charging port needs cleaning. Can anyone recommend anywhere that can do this for me? If it were my phone I'd go anywhere but don't want to risk the deck being broken.
  
  submitted by /u/victorianas
  [link] [comments]
8. 🔗 r/wiesbaden Freude finden rss
  
  Yo, ich bin Ayman, 21, und habe in der Stadt noch keinen Anschluss. Ich suche ein paar Freunde im Alter von 19 bis 29
  
  submitted by /u/Superb_Gas7119
  [link] [comments]
9. 🔗 r/wiesbaden No Tyrants Protest this Saturday, Schlossplatz from 1:00 to 3:00 PM rss
  
  I will also be making a speech.
  
  submitted by /u/ramona_rox
  [link] [comments]
10. 🔗 r/Leeds Our Hero Nathan Newby 🫡 rss
  
  I know it's already been spoken about, but this man is incredible. He saved many lives.
  
  BBC News - Patient hugged armed man to prevent bomb attack at Leeds hospital - BBC News https://www.bbc.co.uk/news/articles/c9q58xq9lxzo?app-referrer=push- notification
  
  submitted by /u/Johnbo_
  [link] [comments]
11. 🔗 r/york Life in York? rss
  
  I'm considering working at the university of York. If I move to York, what's it like there as compared to my hometown Milton Keynes?
  
  submitted by /u/Beautiful_Shine_6787
  [link] [comments]
12. 🔗 backnotprop/plannotator v0.15.2 release
  Follow @plannotator on X for updates
  
  Missed recent releases? Release | Highlights
  ---|---
  v0.15.0 | Live AI chat in code review, plan archive browser, folder file viewer, resizable split pane, Pi full feature parity
  v0.14.5 | GitLab merge request review, login page image fix, Windows install path fix
  v0.14.4 | GitHub review submission, repo identifier in tab title, nested code fence parser fix, Pi paste URL wiring, file header gap fix
  v0.14.3 | PR context panel, diff search in code review, OpenCode permission normalization, landing page redesign
  v0.14.2 | OpenCode plan mode prompt replacement, Windows non-ASCII path fix, Pi link fix
  v0.14.1 | Single submit_plan with auto-detect, viewed-file draft persistence, Bear nested tag fix
  v0.14.0 | PR review via GitHub URL, /plannotator-last for annotating agent messages, OpenCode plan mode permissions fix, VS Code SSH proxy fix
  v0.13.1 | OpenCode plan mode rewrite, Obsidian save fix
  v0.13.0 | Built-in themes, annotatable plan diffs, file-scoped code review comments, Octarine integration, unified review core, Pi remote sessions
  v0.12.0 | Quick annotation labels, mobile compatibility, Graphviz rendering, markdown images with lightbox, linked doc navigation in annotate mode
  v0.11.4 | Git add from code review, bidirectional scroll navigation, clipboard paste for annotation images, VS Code IPC port stability
  
  What's New in v0.15.2
  
  v0.15.2 introduces Compound Planning, adds folder annotation, the /plannotator-archive slash command, and fixes Pi's plan tool scoping. 5 PRs, 1 from an external contributor.
  
  Compound Planning: Learn From Your Own Planning Patterns
  
  Skill: /plannotator-compound
  
  Demo: https://x.com/plannotator/status/2036607307979886984
  
  Compound Planning is a new skill that surfaces your own insights: what kinds of plans get denied, what feedback you give most often, how your planning has evolved over time. The goal is to consistently refine and optimize the planning that works best for you, and eventually create an automated feedback loop between your review patterns and your agent's planning behavior.
  
  This is the first step toward a system where your agent gets better at planning for you specifically , based on your actual history of approvals, denials, and annotations.
  
  The platform install scripts now install Plannotator's skill (just 1 for now) automatically alongside the binary.
  - #390
  Annotate Entire Folders
  
  plannotator annotate now accepts a directory path. Instead of opening a single file, it starts the annotate server with the sidebar Files tab pre- loaded, showing all markdown files in that directory. The viewer starts empty with a prompt to select a file. This lets you review and annotate an entire folder of docs, specs, or notes in one session.
  
  Works in both the Bun hook and the Pi extension.
  - #389
  /plannotator-archive Slash Command
  
  The plan archive browser was previously only accessible via the CLI (plannotator archive) and the Pi extension. This release adds /plannotator- archive as a slash command for Claude Code and OpenCode, so all three runtimes can browse saved plan decisions the same way. The archive is read- only: it opens the browser, you browse your plans, and it closes when you're done.
  - #388
  Additional Changes
  - Pi plan tool scoping. The Pi extension's plan submission tool was renamed to plannotator_submit_plan and is now hidden outside of planning mode. Previously, the tool was visible globally, which could confuse the agent. The fix also properly restores the pre-plan tool set when planning ends (#387 by @dmmulroy, closing #386)
  - Pi AI backbone bundling. The @plannotator/ai package was missing from published Pi packages because it's a private workspace dependency. AI files are now copied into generated/ai/ at build time, matching the existing pattern for shared utilities. Pi users installing from npm now get AI features in code review.
  Install / Update
  
  macOS / Linux:
```
curl -fsSL https://plannotator.ai/install.sh | bash
```
  Windows:
```
irm https://plannotator.ai/install.ps1 | iex
```
  Claude Code Plugin: Run /plugin in Claude Code, find plannotator , and click "Update now".
  
  OpenCode: Clear cache and restart:
```
rm -rf ~/.bun/install/cache/@plannotator
```
  Then in opencode.json:
```
{
  "plugin": ["@plannotator/opencode@latest"]
}
```
  Pi: Install or update the extension:
```
pi install npm:@plannotator/pi-extension
```
  What's Changed
  - fix: Pi plan tool scoping by @dmmulroy in #387
  - feat: add /plannotator-archive slash command by @backnotprop in #388
  - feat: support folder annotation via plannotator annotate by @backnotprop in #389
  - feat: install skills via git sparse-checkout in platform install scripts by @backnotprop in #390
  - fix(pi): bundle AI backbone into generated/ for published package by @backnotprop in 1175ef6
  Community
  
  @dmmulroy authored the Pi plan tool scoping fix (#387), which he also reported in #386. This is his third contribution to the project.
  
  Full Changelog : v0.15.0...v0.15.2
13. 🔗 r/reverseengineering es posible bypassear un bot de opciones binarias o crackear licencias? usa google sheets para administrar. pregunto porque me estafaron y quiero aunque sea ver si funciona ese .exe rss
  
  submitted by /u/One_Boot3047
  [link] [comments]
14. 🔗 r/LocalLLaMA Throwback to my proudest impulse buy ever, which has let me enjoy this hobby 10x more rss
  
  | Can you beleive I almost bought two of them?? (oh, and they gave me 10% cashback for Prime Day) submitted by /u/gigaflops_
  [link] [comments]
  ---|---
15. 🔗 Cal Paterson "Disregard that!" attacks rss
  
  Why you shouldn't share your context window with others
16. 🔗 Mario Zechner Thoughts on slowing the fuck down rss
  
  Thoughts on slowing the fuck down
March 24, 2026
1. 🔗 IDA Plugin Updates IDA Plugin Updates on 2026-03-24 rss
  IDA Plugin Updates on 2026-03-24
  
  New Releases:
  Activity:
  - augur
    
    2b6f8984: chore: update dependencies
  - binsync
    
    e0efc65e: Bump to remove dep connection to LiteLLM
  - fifam
    
    e9cf4a13: weather -> climate conversion
  - ghidra
    
    55664a36: Merge remote-tracking branch 'origin/Ghidra_12.1'
    
    84830f13: GP-0: Fixing javadoc
  - ghidra-chinese
    
    55664a36: Merge remote-tracking branch 'origin/Ghidra_12.1'
    
    84830f13: GP-0: Fixing javadoc
  - Greffe
    
    96dc105c: Readme update
    
    099aaf93: User can now set patch_base
    
    ba2b1282: README update
    
    24c55ea6: fixed double free on exit
    
    fdc67aee: deleted ofiles
    
    10b953dd: Bounds checks
    
    90886a7b: Cmd injection
    
    bb02f63d: Handled sigint
    
    bad67e6c: bin_base retrieved from ida
  - HappyIDA
    
    e5769b3c: fix: use lvar_t.tif via mba for function pointer calls
    
    07c08350: fix: replace removed getv() API for IDA Pro 9.3 compatibility
  - haruspex
    
    85e6f66e: chore: update dependencies
  - ida-cyberchef
    
    48b5fa31: v0.2.0
    
    ff93b54a: ci: install pyside6
    
    c3d593b0: ruff check I
    
    f240a18d: ruff format check
    
    60f37a4e: init: more direct Qt imports
    
    8a1e7eb6: ruff check
    
    8a0de6d4: add linting config
    
    d74ddf4d: Surface invalid manual input state
    
    d5d1eb61: pyproject: move pyside to extras group "qt"
    
    cbe25c0f: remove some xfails
  - ida-domain
    
    c1e7bdc0: docs: fix docstring_style from sphinx to google (#62)
  - ida-hcli
    
    d82d7a76: 0.17.0
    
    cc3a8686: Remove supabase-auth dependency completely
    
    e0e08395: Remove pyyaml dependency
    
    6bed0632: Replace supabase with supabase-auth and drop requests/gotrue
    
    7cfd3e6a: test: add DefaultURLHandler tests
    
    3f2a9612: fix: Windows path separator in test_default_path
  - ida-sdk
    
    1aa34408: Update ida-cmake submodule (fix bootstrap path)
  - idamagicstrings
    
    24c7b5b7: Removed dashes
  - pharos
    
    8829e885: Merge pull request #300 from sei-eschwartz/dh_username
    
    a04ba77c: Attempt to run without DOCKERHUB_USERNAME
  - playlist
    
    5fabb285: de todito
  - python-elpida_core.py
    
    14eaa55c: Add Discord Control Room webhook integration
    
    379c01b0: Fix provider warnings + break PSO A0 monoculture
  - rhabdomancer
    
    36357d7d: chore: update dependencies
  - Rikugan
    
    c51b2003: Merge pull request #31 from buzzer-re/dev
    
    518f59b3: remove comments from requirements, broken binja plugin
    
    3237522f: fix(plugin): make plugin version dynamic and bump to v1.2.0
2. 🔗 r/Harrogate Great food suggestions rss
  
  Hello. I'm looking for restaurant recommendations for my friend and I on Saturday evening? Something with great starters ideally, as I love a starter over a dessert! Something not too fancy. Just friends going out for good food.
  
  Many thanks in advance ☺️
  
  submitted by /u/Chronic_Eyeroller_
  [link] [comments]
3. 🔗 r/LocalLLaMA Prices finally coming down? 🥺🙏 rss
  
  | submitted by /u/PsychologicalSock239
  [link] [comments]
  ---|---
4. 🔗 r/Yorkshire Gannets fencing… Bempton Cliffs rss
  
  | submitted by /u/aspiranthighlander
  [link] [comments]
  ---|---
5. 🔗 r/Yorkshire Where to live in Yorkshire? rss
  
  Hello,
  
  My husband is from Oldham and he has been living in California and Colorado for the past 11-12 years since graduating Uni. We me in California and moved to Colorado 5 years ago. He's over our hustle culture and wants to return to England, and be closer to his family. WE just don't have help out here, not even for your occasional date night. My family is too spread out all over the US and its all places we just wouldn't live - whether that is because of high cost, weather or politics. Then I think he has just gone so long without his own support system, its important that we have that for him and our kids.
  
  He is a British citizen, and our kids our dual. I'll be applying for the spousal visa. So we don't need to get into the immigration stuff.
  
  Essentially we are trying to figure out where to live in Yorkshire. We don't want to go past York, as that is too far from his family in Oldham and then his sister lives in York, so we would like to be able to see her and then also be able to meet up with both sides of the family easily still.
  
  We are looking for:
  
  - Good schools (we have primary aged children)
  - Safe communities (we want to know our kids are safe walking to and from school or that I can jog solo, or hike solo)
  - Strong sense of community but not so strong that people are cold or rude
  - Strong sense of English culture and history (After my husband being away for so long, that’s become important to my husband, for our kids to grow up connected to that side of their identity.)
  - Budget to buy £250,000 (preferably below that, no flats)
  - Budget to rent: £1,200 or less (also would prefer no flats)
  - Walkable to school, grocery, and or high street. This is negotiable as we are used to driving everywhere but walking to everything is just nice.
  - Close to a motorway or train, could be one or the other, so this too is negotiable if the town/city/village is walkable with lots of shops.
  - Politically, we wouldn't identify either left, right or green. We just want balanced and normal.
  - Religion, we aren't really religious. But we likely live by some flavor of Christianity? If anything I'd say we are more so agnostic? Like that's great if there is a god, and if there's not a god, we still just believe in being good people. So we're open to going to church, we just don't like the whole in your face productions that American churches sort of put on.
  - Work/Jobs: I am flexible, I am happy doing almost anything. I have done the whole corporate and office jobs, they make me miserable. My husband has his Bachelors in Physical Education and he is currently the director of a youth soccer club. He oversees an entire age range for our region. He'd like to stay in youth sports/sports as a career but know that may not translate. So he is then open to working in some other field and would still like to coach at least one team in his free time.
  
  We know every place has its pros & cons. Just hoping for genuine recommendations from people who actually know the region.
  
  We have asked this question in some other groups and a few suggestions we have had were:
  
  - Todmorden, Hebden Bridge, Holmfirth, Wakefield, Barnsley and a few others.
  
  Part of the issue is, many people will make a suggestion and not say what is good or bad. Or someone will make a suggestion of a place to avoid but just say its sh!t.
  
  Then people have also said for our budget we won't find much but we are looking on Rightmove and we see a ton of stuff available below £250,000. Which again, coming from the states, we can't get into anything at $300,000, and if we did find something then its a fixer upper, there are HOA fees and if we don't put 20% down then we have to pay property mortgage insurance - which is separate from actual homeowners insurance, which that's becoming increasingly unaffordable and some companies are leaving the state altogether.
  
  So we'd love to hear your suggestions and why or why not. We'd obviously like to check most our boxes but its okay if it doesn't check every once. Top two priorities would be safe community and good schools.
  
  Thank you in advance!
  
  submitted by /u/arg2325
  [link] [comments]
6. 🔗 News Minimalist 🐢 Scientists move antimatter by truck for the first time + 13 more stories rss
  
  In the last 7 days Gemini read 205818 top news stories. After removing previously covered events, there are 14 articles with a significance score over 5.5.
  
  [5.8] Scientists successfully transport antimatter in a truck at CERN —nos.nl(Dutch) (+6)
  
  Scientists at CERN successfully transported antimatter by truck for the first time, marking a breakthrough that enables moving these volatile particles to external laboratories for advanced precision research.
  
  The test utilized a specialized one-ton container carrying 92 antiprotons suspended in electromagnetic fields at extreme sub-zero temperatures. This technology prevents the particles from annihilating upon contact with regular matter during transit, ensuring they remain stable despite the truck's movement.
  
  Future trips to sites like Düsseldorf aim to investigate why matter dominates the universe. Researchers are now developing long-range power sources to support the ten-hour journeys required for international transport.
  
  [6.2] Australia and the EU finalize comprehensive trade agreement after eight years of negotiations —rfi.fr(+56)
  
  The European Union and Australia signed a landmark free-trade agreement Tuesday, concluding eight years of negotiations to diversify markets and secure critical mineral supplies amid rising global trade tensions.
  
  The deal increases Australian beef exports while resolving disputes over protected geographical names like prosecco and feta. Additionally, both parties established a security partnership to enhance defense cooperation and reduce economic over-reliance on major powers like China for essential raw materials.
  
  EU officials estimate regional exports will grow significantly, while the pact could boost Australia’s GDP by billions. The agreement addresses energy vulnerabilities and supply chain risks exacerbated by the ongoing Middle East conflict.
  
  Highly covered news with significance over 5.5
  
  [5.7] China now exports more cars to Europe than Europe exports to China — nordkurier.de (German) (+2)
  
  [5.6] FCC bans sale of most wireless routers in the US over security concerns — 9to5mc.com (+19)
  
  [6.7] New mass spectrometry prototype analyzes billions of molecules simultaneously — rockefeller.edu (+2)
  
  [5.6] US and Indonesia sign trade deal for critical minerals and fossil fuels — usnews.com (+4)
  
  [6.6] Lab-grown food pipe offers new hope for young patients — bbc.com (+6)
  
  [6.0] Brazil enacts law to protect minors from harmful online content — apnews.com (+9)
  
  [5.6] New Israeli law grants rabbinical courts power over civil disputes, raising fears of a theocratic state — ar.timesofisrael.com (Arabic) (+2)
  
  [5.6] US judge strikes down Pentagon press coverage restrictions — npr.org (+24)
  
  [5.5] Johnson & Johnson gains US approval for new daily psoriasis pill — statnews.com (+8)
  
  [6.4] Lab-grown muscle propels swimming robot to record speed — news.nus.edu.sg (+2)
  
  [5.8] Bavarian authorities shut down 373,000 darknet sites in major operation — science.orf.at (German) (+10)
  
  [5.5] One in eight U.S. adults use GLP-1 drugs for weight loss and other health benefits — latimes.com (+6)
  
  Thanks for reading!
  
  — Vadim
  
  You can create your own significance-based RSS feed with premium.
  
  Powered by beehiiv
7. 🔗 r/york Are bluebells out yet anywhere? rss
  
  Does anyone know? We've had a bit of sun now (until tonight lol).
  
  submitted by /u/Massive-Medicine5413
  [link] [comments]
8. 🔗 r/LocalLLaMA Best model that can beat Claude opus that runs on 32MB of vram? rss
  
  Hi everyone! I want to get in to vibe coding to make my very own ai wrapper, what are the best models that can run on 32MB of vram? I have a GeForce 256, and an intel pentium 3, i want to be able to run a model on ollama that can AT LEAST match or beat Claude opus, any recommendations?
  
  submitted by /u/PrestigiousEmu4485
  [link] [comments]
9. 🔗 r/Yorkshire Government announces 40 new school-based nurseries in Yorkshire to help cut childcare costs rss
  
  The Department for Education announced yesterday that a further 331 schools across the country have been successful in applying for a share of £45 million funding to build or expand nurseries on their site.
  
  This includes 40 schools in Yorkshire – full list available on the gov.uk website.
  
  Local Authority | School Name
  ---|---
  Barnsley | Brierley Church of England Voluntary Controlled Primary School
  Calderdale | Trinity Academy Whitehill
  Doncaster | Canon Popham CofE Primary Academy
  | Castle Academy
  East Riding of Yorkshire | Market Weighton Infant School
  | St Mary & St Joseph Catholic Primary School - a Catholic voluntary academy
  | St Mary's Catholic Primary School - a Catholic voluntary academy
  Kingston upon Hull, City of | Francis Askew Primary School
  | St Richard's VC Academy
  Leeds | Allerton Bywater Primary School
  | Blackgates Primary Academy
  | Christ Church Upper Armley Church of England Primary School
  | Collingham Lady Elizabeth Hastings Church of England Voluntary Aided Primary School
  | Greenhill Primary School
  | Holy Name Catholic Voluntary Academy
  | Kippax North Primary School
  | Middleton Primary School
  North Yorkshire | Aiskew, Leeming Bar Church of England Primary School
  | Bentham Community Primary School
  | Brompton and Sawdon Community Primary School
  | Brompton-on-Swale Church of England Primary School
  | Brougham Street Nursery School
  | Hensall Community Primary School
  | Pickhill Church of England Primary School
  | Settrington All Saints' Church of England Voluntary Controlled Primary School
  | St Mary's Catholic Primary School - a Catholic voluntary academy
  | St Peter's Catholic Primary School - a Catholic voluntary academy
  | Willow Tree Community Primary School
  Rotherham | Roughwood Primary School
  | Thurcroft Infant School
  | Woodsetts Primary School
  Sheffield | Beighton Nursery Infant School
  | Bradfield Dungworth Primary School
  | Clifford All Saints CofE Primary School
  | Hillsborough Primary School
  | Pye Bank CofE Primary School
  Wakefield | Carleton Park Junior and Infant School
  | Crigglestone Nursery School
  | Orchard Head Junior and Infant and Nursery School
  York | St Aelred's Catholic Primary School - a Catholic Voluntary Academy
  
  New figures published yesterday show around a million parents now use the government’s funded childcare offer. But the data also reveals lower take-up in poorer communities, highlighting the need to target new places where families face the biggest barriers to accessing childcare.
  
  School-based nurseries already play a major role in filling those gaps, making up around 35% of childcare provision in the most deprived areas, compared with 16% in the least deprived.
  
  Find out more: https://www.gov.uk/government/news/new-school-nurseries-to- help-cut-childcare-costs-in-poorest-areas
  
  submitted by /u/UKGovNews
  [link] [comments]
10. 🔗 r/Leeds Hello lovely people of Leeds. I'm coming to Leeds with my wife for her 40th birthday and looking for restaurant recommendations rss
  
  I originally booked up because I wanted to go to El Gato Negro, the Manchester restaurant is our favourite restaurant and we've been keen to go for many years. Imagine my surprise to find it closed 2 years ago!!
  
  I'd like somewhere that would be similar, not necessarily in food but in quality and atmosphere. Ideally somewhere good for lunch as we will have our daughter with us (she's a good eater and has fancy tastes).
  
  Any help gratefully received and much appreciated.
  
  submitted by /u/RobFratelli
  [link] [comments]
11. 🔗 r/LocalLLaMA [Developing situation] LiteLLM compromised rss
  
  | https://preview.redd.it/2j4q6tni60rg1.png?width=1250&format=png&auto=webp&s=31713cf00753ba517ec22e059d832cf5c456b4e6 Stay safe y'all. https://github.com/BerriAI/litellm/issues/24512 submitted by /u/OrganizationWinter99
  [link] [comments]
  ---|---
12. 🔗 r/LocalLLaMA LM Studio may possibly be infected with sophisticated malware. rss
  
  | NO VIRUS LM studio has stated it was a false positive and Microsoft dealt with it I'm no expert, just a tinkerer who messed with models at home, so correct me if this is a false positive, but it doesn't look that way to me. Anyone else get this? showed up 3 times when i did a full search on my main drive. I was able to delete them with windows defender, but might do a clean install or go to linux after this and do my tinkering in VMs. It seems this virus messes with updates possibly, because I had to go into commandline and change some update folder names to get windows to search for updates. Dont get why people are downvoting me. i loved this app before this and still might use it in VMs, just wanted to give fair warning is all. gosh the internet has gotten so weird. edit LM Studio responded that it was a false alarm on microslops side. Looks like we're safe. submitted by /u/mooncatx3
  [link] [comments]
  ---|---
13. 🔗 r/LocalLLaMA Created a SillyTavern extension that brings NPC's to life in any game rss
  
  | Using SillyTavern as the backend for all the RP means it can work with almost any game, with just a small mod acting as a bridge between them. Right now I’m using Cydonia as the RP model and Qwen 3.5 0.8B as the game master. Everything is running locally. The idea is that you can take any game, download its entire wiki, and feed it into SillyTavern. Then every character has their own full lore, relationships, opinions, etc., and can respond appropriately. On top of that, every voice is automatically cloned using the game’s files and mapped to each NPC. The NPCs can also be fed as much information per turn as you want about the game world - like their current location, player stats, player HP, etc. All RP happens inside SillyTavern, and the model is never even told it’s part of a game world. Paired with a locally run RP-tuned model like Cydonia, this gives great results with low latency, as well as strong narration of physical actions. A second pass is then run over each message using a small model (currently Qwen 3.5 0.8B) with structured output. This maps responses to actual in-game actions exposed by your mod. For example, in this video I approached an NPC and only sent “ shoots at you ”. The NPC then narrated themselves shooting back at me. Qwen 3.5 reads this conversation and decides that the correct action is for the NPC to shoot back at the player. Essentially, the tiny model acts as a game master, deciding which actions should map to which functions in-game. This means the RP can flow freely without being constrained to a strict structure, which leads to much better results. In older games, this could add a lot more life even without the conversational aspect. NPCs simply reacting to your actions adds a ton of depth. Not sure why this isn’t more popular. My guess is that most people don’t realise how good highly specialised, fine-tuned RP models can be compared to base models. I was honestly blown away when I started experimenting with them while building this. submitted by /u/goodive123
  [link] [comments]
  ---|---
14. 🔗 r/LocalLLaMA Litellm 1.82.7 and 1.82.8 on PyPI are compromised, do not update! rss
  
  We just have been compromised, thousands of peoples likely are as well, more details updated here: https://futuresearch.ai/blog/litellm-pypi-supply-chain- attack/
  
  Update: My awesome colleague Callum McMahon, who discovered this, wrote an explainer and postmortem going into greater detail: https://futuresearch.ai/blog/no-prompt-injection-required
  
  submitted by /u/kotrfa
  [link] [comments]
15. 🔗 r/wiesbaden Uranium glass rss
  
  Hello, I am visiting Wiesbaden for few days and I would like to buy some uranium glass. Are there any shops with glass or some cool antiques I can find? Thank you
  
  submitted by /u/barborka47
  [link] [comments]
16. 🔗 HexRaysSA/plugin-repository commits sync repo: +1 plugin, +2 releases rss
```
sync repo: +1 plugin, +2 releases

## New plugins
- [idamagicstrings](https://github.com/joxeankoret/idamagicstrings) (1.2.0)

## New releases
- [ida-cyberchef](https://github.com/HexRaysSA/ida-cyberchef): 0.2.0
```
17. 🔗 r/Yorkshire Different moods of Whitby rss
  
  | submitted by /u/angryestbadger
  [link] [comments]
  ---|---
18. 🔗 r/Leeds Town Hall in the Snow rss
  
  submitted by /u/angryestbadger
  [link] [comments]
19. 🔗 r/Yorkshire Fountains Abbey in the sun rss
  
  | submitted by /u/angryestbadger
  [link] [comments]
  ---|---
20. 🔗 r/Yorkshire Views over Scar House rss
  
  | submitted by /u/angryestbadger
  [link] [comments]
  ---|---
21. 🔗 r/reverseengineering Reverse Engineering a "Zombie" Smart Scale: My journey with QardioBase2 after the app vanished. rss
  
  submitted by /u/Reversed-Engineer-01
  [link] [comments]
22. 🔗 backnotprop/plannotator v0.15.0 release
  Follow @plannotator on X for updates
  
  Missed recent releases? Release | Highlights
  ---|---
  v0.14.5 | GitLab merge request review, login page image fix, Windows install path fix
  v0.14.4 | GitHub review submission, repo identifier in tab title, nested code fence parser fix, Pi paste URL wiring, file header gap fix
  v0.14.3 | PR context panel, diff search in code review, OpenCode permission normalization, landing page redesign
  v0.14.2 | OpenCode plan mode prompt replacement, Windows non-ASCII path fix, Pi link fix
  v0.14.1 | Single submit_plan with auto-detect, viewed-file draft persistence, Bear nested tag fix
  v0.14.0 | PR review via GitHub URL, /plannotator-last for annotating agent messages, OpenCode plan mode permissions fix, VS Code SSH proxy fix
  v0.13.1 | OpenCode plan mode rewrite, Obsidian save fix
  v0.13.0 | Built-in themes, annotatable plan diffs, file-scoped code review comments, Octarine integration, unified review core, Pi remote sessions
  v0.12.0 | Quick annotation labels, mobile compatibility, Graphviz rendering, markdown images with lightbox, linked doc navigation in annotate mode
  v0.11.4 | Git add from code review, bidirectional scroll navigation, clipboard paste for annotation images, VS Code IPC port stability
  v0.11.3 | Expandable diff context, hierarchical folder tree, redesigned worktree controls, supply chain hardening
  
  What's New in v0.15.0
  
  v0.15.0 adds live AI chat to code review, the ability to browse all your previous plans, a folder-based file viewer for referencing docs (e.g. Superpowers) during annotation, and full feature parity for the Pi extension. 11 PRs, 2 from external contributors, 1 first-time.
  
  Live AI Chat in Code Review
  
  You can now talk to an AI directly inside the code review UI. Select lines in a diff and click "Ask AI" to get context-aware explanations about what the code does and why it changed. Or open the AI sidebar tab to ask general questions about the changeset. Responses stream in real-time with full markdown rendering.
  
  Plannotator works with the coding tools you already have installed. On startup, it checks which tools are available on your machine — Claude Code, Codex, Pi, OpenCode — and offers them as providers. You choose which one to use and which model to use with it in Settings. That choice persists across sessions. You can switch providers at any time. The only requirement is that the tool is installed and authenticated locally; Plannotator doesn't handle login or API keys itself.
  
  Under the hood, each tool is accessed through a provider-agnostic layer (@plannotator/ai) that handles session lifecycle, streaming, and tool execution uniformly. Claude and Codex communicate via subprocess, Pi via RPC over JSONL/stdio, and OpenCode via HTTP + SSE. The OpenCode provider supports forked sessions, runtime permission approvals, and dynamic model discovery from connected providers.
  - #363, #377, #379
  Browse All Previous Plans
  
  You can now view every plan you've approved or denied. The plannotator archive command opens a read-only browser of your plan history, with approved/denied badges and timestamps. During normal plan review, a new Archive sidebar tab gives you the same view without leaving the session, so you can reference past decisions while reviewing a new plan.
  
  This replaces the old "Other Plans" UI and removes the dead /api/plan/history endpoint.
  - #369, closing #362 reported by @andreivladmatei
  Attach Folders for Reference During Review
  
  A new Files tab in the sidebar gives you access to all markdown files in your project. Click any file to open it as a linked document with full annotation support. If you have docs, specs, or notes in directories outside the project root, add them in Settings and they show up as additional sections. Useful for power users who want their full documentation library at hand while reviewing or annotating plans.
  
  Works in both plan mode and annotate mode. Directory sections are collapsible, and common non-content directories (node_modules, .git, dist, build, etc.) are excluded.
  - #378, closing #367 requested by @andymac4182
  Resizable Split Pane in Code Review
  
  The split diff viewer now has a draggable divider between left and right panes. Drag to resize; the ratio is clamped to 20-80% and persisted via cookie storage. Double-click the handle to reset to 50/50. The implementation uses CSS custom properties that inherit into Pierre's shadow DOM, so resizing triggers zero re-renders of the diff component. The handle is hidden for add- only or delete-only files where Pierre renders a single column.
  - #383
  Pi Extension: Full Feature Parity
  
  The Pi extension was missing a significant number of features that Claude Code and OpenCode users had access to. PR review, note-taking integrations (Obsidian, Bear, Octarine), plan saving with version history, editor annotations, the file browser, linked doc resolution with security checks, and the AI backbone were all absent or partially implemented. This release closes that gap entirely. Pi users now have access to every feature available on the other platforms.
  
  The server was rewritten from a monolithic server.ts into a modular architecture split across domain-specific modules (serverPlan.ts, serverReview.ts, serverAnnotate.ts, plus shared handlers, reference resolution, annotations, integrations, PR support, and networking). A generated/ directory holds shared code copied from packages/shared/ at build time, so both Bun and Pi consume the same logic for storage, drafts, file resolution, and integrations.
  
  A line-by-line parity audit then verified every endpoint, response shape, error case, and conditional across all three server types. This uncovered and fixed: missing error handling on several endpoints, a broken detectProjectNameSync that silently failed, a missing pasteApiUrl in Bun's annotate server that broke short URL sharing, and stale naming inconsistencies. An automated route parity test now runs in CI to prevent drift going forward.
  - #382, closing #381
  Additional Changes
  - OpenPackage manifest. Adds openpackage.yml for installation via opkg install plannotator (#368 by @TiagoJacinto)
  - Duplicate code review header fix (Pi). The # Code Review Feedback heading appeared twice when the Pi extension submitted review feedback. The wrapper no longer adds a redundant header (#370 by @dmmulroy)
  - Duplicate code review header fix (OpenCode). Same issue in the OpenCode plugin (#375, closing #374 reported by @nulladdict)
  - Empty submit in annotate mode. The annotate UI no longer blocks submission when there are no annotations. Linked doc annotations are now counted in validation, fixing a case where annotations on linked documents couldn't be submitted (#376, closing #371 and #373 reported by @bman654)
  - Sidebar resize handle fix. The left sidebar handle was visible on hover but couldn't be grabbed due to a touch area regression from v0.14.5. Fixed with asymmetric positioning that avoids covering scrollbars.
  - Linked doc border styling. The border around linked documents (Obsidian files, project files, archive plans) is now thinner and more subtle — 1px at 40% opacity instead of the previous 2px solid primary.
  Install / Update
  
  macOS / Linux:
```
curl -fsSL https://plannotator.ai/install.sh | bash
```
  Windows:
```
irm https://plannotator.ai/install.ps1 | iex
```
  Claude Code Plugin: Run /plugin in Claude Code, find plannotator , and click "Update now".
  
  OpenCode: Clear cache and restart:
```
rm -rf ~/.bun/install/cache/@plannotator
```
  Then in opencode.json:
```
{
  "plugin": ["@plannotator/opencode@latest"]
}
```
  Pi: Install or update the extension:
```
pi install npm:@plannotator/pi-extension
```
  What's Changed
  - feat(ai): AI backbone + inline chat for code review by @backnotprop in #363
  - Add OpenPackage manifest by @TiagoJacinto in #368
  - feat: plan archive browser by @backnotprop in #369
  - fix: remove duplicate 'Code Review' header in pi extension review feedback by @dmmulroy in #370
  - fix: remove duplicate 'Code Review' header in opencode plugin by @backnotprop in #375
  - fix: allow empty submit and count linked doc annotations in annotate mode by @backnotprop in #376
  - feat(ai): Pi provider via RPC subprocess by @backnotprop in #377
  - feat: markdown file browser sidebar tab by @backnotprop in #378
  - feat(ai): OpenCode provider via HTTP + SSE by @backnotprop in #379
  - feat(pi): complete Pi server rewrite — modular architecture, full Bun parity, shared code extraction by @backnotprop in #382
  - feat: resizable split pane for code review diff viewer by @backnotprop in #383
  New Contributors
  - @TiagoJacinto made their first contribution in #368
  Contributors
  
  @TiagoJacinto added the OpenPackage manifest (#368), enabling installation via opkg. First contribution to the project.
  
  @dmmulroy fixed the duplicate code review header in the Pi extension (#370), a follow-up to his paste URL wiring work in v0.14.4.
  
  Community members who reported issues that drove changes in this release:
  - @andreivladmatei: #362 (plan archive feature request)
  - @andymac4182: #367 (file browser / folder annotation request)
  - @bman654: #371 and #373 (annotate mode submission bugs)
  - @nulladdict: #374 (duplicate header in OpenCode review feedback)
  Full Changelog : v0.14.5...v0.15.0
23. 🔗 r/Leeds Just moved from Brazil and looking for the best coffee spots! ☕️🇧🇷 rss
  
  Hi everyone! I recently arrived in leeds and I'm still trying to find my way around. I'm looking for a cozy café where I can sit, read a bit, or just enjoy a good espresso. Any hidden gems you guys would recommend? Not a fan of the big chains, I prefer local spots! Thanks in advance. ✨
  
  submitted by /u/Standard_Ad_2739
  [link] [comments]
24. 🔗 sacha chua :: living an awesome life Categorizing Emacs News items by voice in Org Mode rss
  I'm having fun exploring which things might actually be easier to do by voice than by typing. For example, after I wrote some code to expand yasnippets by voice, I realized that it was easier to:
  1. press my shortcut,
  2. say "okay, define interactive function",
  3. and then press my shortcut again,
  than to:
  1. mentally say it,
  2. get the first initials,
  3. type in "dfi",
  4. and press Tab to expand.
  Another area where I do this kind of mental translation for keyboard shortcuts is when I categorize dozens of Emacs-related links each week for Emacs News. I used to do this by hand. Then I wrote a function to try to guess the category based on regular expressions (my-emacs-news-guess-category in emacs-news/index.org, which is large). Then I set up a menu that lets me press numbers corresponding to the most frequent categories and use tab completion for the rest. 1 is Emacs Lisp, 2 is Emacs development, 3 is Emacs configuration, 4 is appearance, 5 is navigation, and so on. It's not very efficient, but some of it has at least gotten into muscle memory, which is also part of why it's hard to change the mapping. I don't come across that many links for Emacs development or Spacemacs, and I could probably change them to something else, but… Anyway.
  
  Figure 1: Screenshot of my menu for categorizing links
  
  I wanted to see if I could categorize links by voice instead. I might not always be able to count on being able to type a lot, and it's always fun to experiment with other modes of input. Here's a demonstration showing how Emacs can automatically open the URLs, wait for voice input, and categorize the links using a reasonably close match. The *Messages* buffer displays the recognized output to help with debugging.
  
  Screencast with audio: categorizing links by voice
  
  This is how it works:
  1. It starts an ffmpeg recording process.
  2. It starts Silero voice activity detection.
  3. When it detects that speech has ended, it use curl to send the WAV to an OpenAI-compatible server (in my case, Speaches with the Systran/faster-whisper-base.en model) for transcription, along with a prompt to try to influence the recognition.
  4. It compares the result with the candidates using string-distance for an approximate match. It calls the code to move the current item to the right category, creating the category if needed.
  Since this doesn't always result in the right match, I added an Undo command. I also have a Delete command for removing the current item, Scroll Up and Scroll Down, and a way to quit.
  Initial thoughts
  
  I used it to categorize lots of links in this week's Emacs News, and I think it's promising. I loved the way my hands didn't have to hover over the number keys or move between those and the characters. Using voice activity detection meant that I could just keep dictating categories instead of pressing keyboard shortcuts or using the foot pedal I recently dusted off. There's a slight delay, of course, but I think it's worth it. If this settles down and becomes a solid part of my workflow, I might even be able to knit or hand-sew while doing this step, or simply do some stretching exercises.
  
  What about using streaming speech recognition? I've written some code to use streaming speech recognition, but the performance wasn't good enough when I tried it on my laptop (Lenovo P52 released in 2018, no configured GPU under Linux). The streaming server dropped audio segments in order to try to catch up. I'd rather have everything transcribed at the level of the model I want, even if I have to wait a little while. I also tried using the Web Speech API in Google Chrome for real-time speech transcription, but it's a little finicky. I'm happy with the performance I get from either manually queueing speech segments or using VAD and then using batch speech recognition with a model that's kept in memory (which is why I use a local server instead of a command-line tool). Come to think of it, I should try this with a higher-quality model like medium or large, just in case the latency turns out to be not that much more for this use case.
  
  What about external voice control systems like Talon Voice or Cursorless? They seem like neat ideas and lots of people use them. I think hacking something into Emacs with full access to its internals could be lots of fun too.
  
  A lot of people have experimented with voice input for Emacs over the years. It could be fun to pick up ideas for commands and grammars. Some examples:
  
  Using Python to Code by Voice - YouTube (2013)
  
  jgarvin/mandimus: Use speech recognition to command your computer and Emacs. · GitHub
  
  ErikPrantare/cursorfree.el: Edit and navigate from anywhere in the buffer · GitHub
  
  ~lepisma/emacs-speech-input - uses the idea of a voice cursor, uses an LLM to execute editing instructions
  
  What about automating myself out of this loop? I've considered training a classifier or sending the list to a large language model to categorize links in order to set more reasonable defaults, but I think I'd still want manual control, since the fun is in getting a sense of all the cool things that people are tinkering around with in the Emacs community. I found that with voice control, it was easier for me to say the category than to look for the category it suggested and then say "Okay" to accept the default. If I display the suggested category in a buffer with very large text (and possibly category-specific background colours), then I can quickly glance at it or use my peripheral vision. But yeah, it's probably easier to look at a page and say "Org Mode" than to look at the page, look at the default text, see if it matches Org Mode, and then say okay if it is.
  Ideas for next steps
  
  I wonder how to line up several categories. I could probably rattle off a few without waiting for the next one to load, and just pause when I'm not sure. Maybe while there's a reasonably good match within the first 1-3 words, I'll take candidates from the front of the queue. Or I could delimit it with another easily-recognized word, like "next".
  
  I want to make a more synchronous version of this idea so that I can have a speech-enabled drop-in replacement that I can use as my y-or-n-p while still being able to type y or n. This probably involves using sit-for and polling to see if it's done. And then I can use that to play Twenty Questions, but also to do more serious stuff. It would also be nice to have replacements for read-string and completing-read, since those block Emacs until the user enters something.
  
  I might take a side-trip into a conversational interface for M-x doctor and M-x dunnet, because why not. Naturally, it also makes sense to voice-enable agent-shell and gptel interactions.
  
  I'd like to figure out a number- or word-based completion mechanism so that I can control Reddit link replacement as well, since I want to select from a list of links from the page. Maybe something similar to the way voicemacs adds numbers to helm and company or how flexi-choose.el works.
  
  I'm also thinking about how I can shift seamlessly between typing and speaking, like when I want to edit a link title. Maybe I can check if I'm in the minibuffer and what kind of minibuffer I'm in, perhaps like the way Embark does.
  
  It would be really cool to define speech commands by reusing the keymap structure that menus also use. This is how to define a menu in Emacs Lisp:
  
  (easy-menu-define words-menu global-map "Menu for word navigation commands." '("Words" ["Forward word" forward-word] ["Backward word" backward-word]))
  
  and this is how to set just one binding:
  
  (keymap-set-after my-menu "<drink>" '("Drink" . drink-command) 'eat)
  
  That makes sense to reuse for speech commands. I'd also like to be able to specify aliases while hiding them or collapsing them for a "What can I say" help view… Also, if keymaps work, then maybe minor modes or transient maps could work? This sort of feels like it should be the voice equivalent of a transient map.
  The code so far
  
  (defun my-emacs-news-categorize-with-voice (&optional skip-browse) (interactive (list current-prefix-arg)) (unless skip-browse (my-spookfox-browse)) (speech-input-cancel-recording) (let ((default (if (fboundp 'my-emacs-news-guess-category) (my-emacs-news-guess-category)))) (speech-input-from-list (if default (format "Category (%s): " default) "Category: ") '(("Org Mode" "Org" "Org Mode") "Other" "Emacs Lisp" "Coding" ("Emacs configuration" "Config" "Configuration") ("Appearance" "Appearance") ("Default" "Okay" "Default") "Community" "AI" "Writing" ("Reddit" "Read it" "Reddit") "Shells" "Navigation" "Fun" ("Dired" "Directory" "Dir ed") ("Mail, news, and chat" "News" "Mail" "Chat") "Multimedia" "Scroll down" "Scroll up" "Web" "Delete" "Skip" "Undo" ("Quit" "Quit" "Cancel" "All done")) (lambda (result text) (message "Recognized %s original %s" result text) (pcase result ("Undo" (undo) (my-emacs-news-categorize-with-voice t)) ("Skip" (forward-line) (my-emacs-news-categorize-with-voice)) ("Quit" (message "All done.") (speech-input-cancel-recording)) ("Reddit" (my-emacs-news-replace-reddit-link) (my-emacs-news-categorize-with-voice t)) ("Scroll down" (my-spookfox-scroll-down) (my-emacs-news-categorize-with-voice t)) ("Scroll up" (my-spookfox-scroll-up) (my-emacs-news-categorize-with-voice t)) ("Delete" (delete-line) (undo-boundary) (my-emacs-news-categorize-with-voice)) ("Default" (my-org-move-current-item-to-category (concat default ":")) (undo-boundary) (my-emacs-news-categorize-with-voice)) (_ (my-org-move-current-item-to-category (concat result ":")) (undo-boundary) (my-emacs-news-categorize-with-voice)))) t)))
  
  It uses Spookfox to control Firefox from Emacs:
  
  (defun my-spookfox-scroll-down () (interactive) (spookfox-js-injection-eval-in-active-tab "window.scrollBy(0, document.documentElement.clientHeight);" t)) (defun my-spookfox-scroll-up () (interactive) (spookfox-js-injection-eval-in-active-tab "window.scrollBy(0, -document.documentElement.clientHeight);"))
  
  (defun my-spookfox-background-tab (url &rest args) "Open URL as a background tab." (if spookfox--connected-clients (spookfox-tabs--request (cl-first spookfox--connected-clients) "OPEN_TAB" `(:url ,url)) (browse-url url)))
  
  It also uses these functions for categorizing Org Mode items:
  
  (defun my-org-move-current-item-to-category (category) "Move current list item under CATEGORY earlier in the list. CATEGORY can be a string or a list of the form (text indent regexp). Point should be on the next line to process, even if a new category has been inserted." (interactive (list (completing-read "Category: " (my-org-get-list-categories)))) (when category (let* ((col (current-column)) (item (point-at-bol)) (struct (org-list-struct)) (category-text (if (stringp category) category (elt category 0))) (category-indent (if (stringp category) 2 (+ 2 (elt category 1)))) (category-regexp (if (stringp category) category (elt category 2))) (end (elt (car (last struct)) 6)) (pos (point)) s) (setq s (org-remove-indentation (buffer-substring-no-properties item (org-list-get-item-end item struct)))) (save-excursion (if (string= category-text "x") (org-list-send-item item 'delete struct) (goto-char (caar struct)) (if (re-search-forward (concat "^ *- +" category-regexp) end t) (progn ;; needs a patch to ol.el to check if stringp (org-list-send-item item (point-at-bol) struct) (org-move-item-down) (org-indent-item)) (goto-char end) (org-list-insert-item (point-at-bol) struct (org-list-prevs-alist struct)) (let ((old-struct (copy-tree struct))) (org-list-set-ind (point-at-bol) struct 0) (org-list-struct-fix-bul struct (org-list-prevs-alist struct)) (org-list-struct-apply-struct struct old-struct)) (goto-char (point-at-eol)) (insert category-text) (org-list-send-item item 'end struct) (org-indent-item) (org-indent-item)) (recenter)))))) (defun my-org-guess-list-category (&optional categories) (interactive) (require 'cl-lib) (unless categories (setq categories (my-helm-org-list-categories-init-candidates))) (let* ((beg (line-beginning-position)) (end (line-end-position)) (string (buffer-substring-no-properties beg end)) (found (cl-member string categories :test (lambda (string cat-entry) (unless (string= (car cat-entry) "x") (string-match (regexp-quote (downcase (car cat-entry))) string)))))) (when (car found) (my-org-move-current-item-to-category (cdr (car found))) t)))
  
  For the speech-input functions, experimental code is at https://codeberg.org/sachac/speech-input .
  View Org source for this post
  
  You can comment on Mastodon or e-mail me at sacha@sachachua.com.
March 23, 2026
1. 🔗 IDA Plugin Updates IDA Plugin Updates on 2026-03-23 rss
  IDA Plugin Updates on 2026-03-23
  
  New Releases:
  - mcrit-plugin v1.1.5
  Activity:
  - binsync
    
    7baac887: Add diff display when hovering over function diffs in Compare with Co…
  - fifam
    
    3ec7a288: add more attributes for Cities and Regions; struct_updater plugin
  - ida-cyberchef
    
    8bd725ba: mark JWT sign/verify as unsupported due to crypto KeyObject API
    
    dc22ef65: test: fix test vectors for CyberChef v10.22.1 upstream changes
    
    df40c4de: test: stabilize worktree test runs
    
    393179f0: rebuild CyberChef bundle from updated submodule
    
    4d3a9630: update CyberChef submodule to upstream v10.22.1, remove stale patch file
    
    1ba3d912: Merge pull request #40 from HexRaysSA/copilot/clear-stale-previews-er…
    
    ca89c06d: Merge branch 'main' into copilot/clear-stale-previews-errors
    
    de37ac53: Merge pull request #41 from HexRaysSA/copilot/preserve-user-output-di…
    
    a3034963: Merge pull request #37 from HexRaysSA/copilot/centralize-cyberchef-sc…
    
    93473e16: Merge pull request #42 from HexRaysSA/copilot/clear-external-input-state
    
    324f2b85: test: use real execution paths in stale state tests
    
    dd5ec8ac: test: remove fake execution model coverage
    
    ccf2f853: Use real models in output panel tests
    
    2e4ec2f9: Fix schema adapter test regressions
    
    85cbf07a: Merge origin/main into selection fix branch
    
    24828b08: test: relocate recipe panel regressions
    
    24f22b78: Merge pull request #38 from HexRaysSA/copilot/add-hex-view-selection-…
    
    d78afe48: test: move stale state coverage out of recipe panel file
    
    083b7342: Remove standalone plugin selection test file
    
    de2672fb: Polish shared schema adapter integration
  - ida-domain
    
    ffad3a94: docs: add microcode and IDA version badge to docs, unify microcode pr…
    
    e1b78d0f: add serialize/deserialize to MicroInstruction (#60)
  - idafridascript
    
    12d7e8d0: feat(install): :sparkles: Support hcli command ins
  - mcrit-plugin
    
    5ad6b8c6: Merge pull request #5 from r0ny123/batch1-fixes
  - pharos
    
    33f84840: Merge pull request #299 from cmu-sei/update-actions
    
    9ab5d69d: Update github actions
    
    d6a5b68a: Merge pull request #297 from cmu-sei/rm-docker-hub
    
    b28fb691: Merge pull request #298 from cmu-sei/push-docker-hub
    
    178b05ff: Push images to docker hub
    
    9b629c22: Update Docker image references in INSTALL.md
  - playlist
    
    0d7877b7: MC Moon Cave
  - python-elpida_core.py
    
    7bc2d467: Fix WorldEmitter display for Oracle beads
    
    730ebb35: Raise MIND max_tokens 700→1200 + insight summary cap 1000→2000
    
    84426905: Fix PSO key mismatch + Reddit RSS feed + template fatigue
  - recover
    
    f2d1b7a1: Create export directory if it does not exist
    
    41fbdba5: Fix linter errors
2. 🔗 r/wiesbaden Sie im Liliencarré rss
  
  Hey,
  
  heute ist mir eine hübsche Frau mit roten Strähnen im Haar und einem sympathischen Lächeln im Liliencarré entgegengekommen. Wir haben uns kurz angesehen und gelächelt.
  
  Ich weiß nicht, ob Sie sich an den Moment erinnern wird, aber Ihr Lächeln hat mir den Tag gerettet.
  
  Deshalb möchte ich mich mit diesen Zeilen bei Dir dafür bedanken.
  
  Vielleicht sieht man sich ja nochmal.
  
  Liebe Grüße von dem
  
  Mann in der fliederfarbenen Jacke
  
  submitted by /u/wie_throwaway
  [link] [comments]
3. 🔗 r/reverseengineering We got Skype to log in - One major step in figuring out the popular 2000s IM client rss
  
  submitted by /u/Gullible_Injury7023
  [link] [comments]
4. 🔗 r/LocalLLaMA RYS II - Repeated layers with Qwen3.5 27B and some hints at a 'Universal Language' rss
  | So, I've had my H100s grind for you all, and have some interesting new results AND fresh models! So, what did I find? Well because my blog article are too damn long (I know some of you are not reading the whole thing...), here is a TL;DR :
  1. I found that LLMs seem to think in a universal language. During the middle layers, the models latent representations are more similar on the same content in Chinese and English than different content in the same language.
  2. I tried a bunch of different stuff, but in the end, repeating blocks in the middle of the transformer stack works the best.
  3. You should still read the blog: https://dnhkng.github.io/posts/rys-ii/
  If you still didnt read the blog, well, I guess you can just try the models? https://huggingface.co/dnhkng/RYS-Qwen3.5-27B-FP8-S https://huggingface.co/dnhkng/RYS-Qwen3.5-27B-FP8-M https://huggingface.co/dnhkng/RYS-Qwen3.5-27B-FP8-L https://huggingface.co/dnhkng/RYS-Qwen3.5-27B-FP8-XL Wen GGUF? When someone GGUF's them I guess? When you repeat layers, you benefit a lot from fine tuning. I expect the first team to fine tune RYS-Qwen3.5-27B-FP8-XL will have a new SOTA for that size range. Lastly, Ive been chatting with TurboDerp; hopefully we can get this into a new format where you can keep the duplicated later as copies, and not use more VRAM (except for the KV cache). S tay tuned! submitted by /u/Reddactor
  [link] [comments]
  ---|---
5. 🔗 r/wiesbaden Love the city rss
  
  Wiesbaden is a really cool city ... I'm surprised and love how it's designed and the people..it's very serene and charming ..I thought first it's pretty but boring but now I'm amazed..
  
  submitted by /u/Single_Lunch_5671
  [link] [comments]
6. 🔗 r/york Looking for jewellers for valuations rss
  
  Hi everyone,
  
  I’m looking for jewellers in and around York who do valuations of pieces (and possibly do insurance reports, depending on valuations) for some pieces I’ve inherited lately after the death of some relatives
  
  Any suggestions/experiences/thoughts are greatly appreciated
  
  Thanks!!
  
  submitted by /u/Space-cowboy1995
  [link] [comments]
7. 🔗 r/Yorkshire Bartle - Yorkshire Folklore rss
  
  I just stumbled across this lovely film on youtube about a village tradition in Yorkshire dating back to the 1400s. Thought it deserved a share, I hope they get some subs.
  
  https://www.youtube.com/watch?v=BYrx2IypaHY
  
  submitted by /u/Future_You_2800
  [link] [comments]
8. 🔗 r/reverseengineering I built an FPGA reimplementation of the 3dfx Voodoo 1 rss
  
  submitted by /u/r_retrohacking_mod2
  [link] [comments]
9. 🔗 r/reverseengineering TIL you can detect a UEFI bootkit from usermode by just asking it nicely rss
  
  submitted by /u/SapDragons
  [link] [comments]
10. 🔗 @HexRaysSA@infosec.exchange We'll be at the RSA this week! mastodon
  
  We'll be at the RSA this week!
  If you want to talk about VR, AI, malware, and what’s on the IDA roadmap, book some time with us.
  👉 https://meetings-eu1.hubspot.com/chris-hernandez
11. 🔗 r/LocalLLaMA China's open-source dominance threatens US AI lead, US advisory body warns rss
  
  | submitted by /u/Prolapse_to_Brolapse
  [link] [comments]
  ---|---
12. 🔗 r/reverseengineering Using local LLM and Ghidra to analyze malware (Part 2) rss
  
  submitted by /u/moonlightelite
  [link] [comments]
13. 🔗 r/Yorkshire Stargazing and astrophotography experiences in Yorkshire rss
  
  Can anyone recommend some great places to spend the night (not camping, actual rooms) in the Yorkshire Dales / Peak District or North Yorkshire Moors where the skies are really dark and you can stargaze with a telescope and try some astro photography? Looking to gift an experience to my partner for his birthday. Particularly interested in guided experiences if possible at all :)
  
  submitted by /u/Sajola_91
  [link] [comments]
14. 🔗 sacha chua :: living an awesome life 2026-03-23 Emacs news rss
  [2026-03-23 Mon]: Removed elecxzy comment-dwim, whoops.
  
  Might be a good opportunity to set up better auto-saves, with buffer-guardian.el inspiring an update to super-save 0.5. Also, there were a couple of interesting experiments embedding Chromium (Reddit) or native macOS views in Emacs (Reddit), and one about embedding Emacs in a webpage (Reddit).
  - Upcoming events (iCal file, Org):
    
    Emacs Berlin: Emacs-Berlin Hybrid Meetup https://emacs-berlin.org/ Wed Mar 25 1100 America/Vancouver - 1300 America/Chicago - 1400 America/Toronto - 1800 Etc/GMT - 1900 Europe/Berlin - 2330 Asia/Kolkata – Thu Mar 26 0200 Asia/Singapore
    
    Emacs APAC: Emacs APAC meetup (virtual) https://emacs-apac.gitlab.io/announcements/ Sat Mar 28 0130 America/Vancouver - 0330 America/Chicago - 0430 America/Toronto - 0830 Etc/GMT - 0930 Europe/Berlin - 1400 Asia/Kolkata - 1630 Asia/Singapore
    
    EmacsATX: Emacs Social https://www.meetup.com/emacsatx/events/313720093/ Thu Apr 2 1600 America/Vancouver - 1800 America/Chicago - 1900 America/Toronto - 2300 Etc/GMT – Fri Apr 3 0100 Europe/Berlin - 0430 Asia/Kolkata - 0700 Asia/Singapore
    
    M-x Research: TBA https://m-x-research.github.io/ Fri Apr 3 0800 America/Vancouver - 1000 America/Chicago - 1100 America/Toronto - 1500 Etc/GMT - 1700 Europe/Berlin - 2030 Asia/Kolkata - 2300 Asia/Singapore
  - Emacs configuration:
    
    decoupling C-m (aka RET) and <return>
  - Emacs Lisp:
    
    elisp-2025/el-xeger.el (Reddit)- generate text from a regex
    
    [20] Working on Canvas Patch (Contd..) - 3/22/2026, 2:31:11 PM - Dyne.org TV
  - Writing:
    
    miljko/microbe.el: A high-performance, offline-first Emacs manager for Micro.blog · GitHub
    
    blogmore.el v1.7 - davep (also 1.4 update, other post)
  - Appearance:
    
    Chris Maiorana: Writing gloriously long sentences in Emacs with line highlighting (Irreal)
    
    Tip about setting hl-line-range-function to identify current line in visual line mode
    
    Protesilaos Stavrou: Emacs: doric-themes version 1.1.0
  - Navigation:
    
    repo-grep.el – update
  - Dired:
    
    Emacs - Rename currently opened file in Dired mode (03:21)
  - Org Mode:
    
    Which org-related packages do you use?
    
    Taking Notes With Emacs Org Mode (It's Easy!) (15:35)
    
    Reading your Emacs notes on-the-go, minimally. (12:07, (Reddit)
    
    Srijan Choudhary: 2026-03-18-001: move Org heading title into body
    
    Resilient Technologies. Why Decades-Old Tools Define the ROOT of Modern Research Data Management — Workshop Documents (@lukascbossert@mastodon.social)
  - Coding:
    
    aspiers/madolt: magit-like emacs mode for dolt · GitHub (Reddit)
    
    Emacs VC-mode in action (01:34)
    
    Projeto Omega - Cifra de Cesar (Emacs+Magit) (14:39)
    
    Lycomedes1814/temme-mode: A rewrite of emmet-mode for Emacs, aiming for a clean and modern codebase · GitHub (Reddit)
    
    Emacs Redux: surround.el: Vim-Style Pair Editing Comes to Emacs (Irreal)
    
    Emacs Redux: Tree-sitter Font-Lock and Indentation in Comint Buffers
    
    Tip about using python-indent-def-block-scale - mutliplier applied to indentation
    
    Einar Mostad: Use virtual environment in Emacs' Python Mode if in a project with a venv
    
    Monday Live Coding with Emacs. 3/16/2026 #coding #livecoding #emacs #learnc (01:16:08)
  - Mail, news, and chat:
    
    newsflash.el I built a lightweight RSS news reader for Emacs with split-screen reading (Reddit)
  - Multimedia:
    
    emacs-os/elcava: Cava clone in emacs lisp · GitHub (Reddit) Audio spectrum visualizer
    
    jellyfin-emms-mpv.el - Browse and play music/video from a Jellyfin server via EMMS + mpv (Reddit)
  - Fun:
    
    emacs is really good for ascii-art (Reddit)
    
    Run Emacs in your browser with v86 (Reddit)
    
    zenitsu7772000/manga-reader - Manga & Comic Reader for Emacs (Reddit)
  - AI:
    
    Agile & Coding: The tools of an Agentic Engineer (Reddit)
    
    jlouisbiz/rcd-mcp-emacs-documentation: get_documentation, list_functions_by_prefix, search_functions, rcd_elisp_function_definition
    
    MCP for Emacs - Improve your notes with ORG MODE 🦄 (10:27)
    
    agent-shell-notifications released! (Reddit)
    
    Jeremias-A-Queiroz/emacs-gptel-slim-tools: leverage etags for precise code fragment extraction (Reddit)
    
    Fritz Grabo: acp2ollama in Emacs for fun and profit
    
    James Dyer: Ollama Buddy - Seven Lines to Any LLM Provider
  - Community:
    
    I tried Neovim, but I keep coming back to Emacs
    
    Eric MacAdie: Emacs Carnival: Mistakes and Misconceptions
  - Shells:
    
    Making Emacs output true 24-bit color in the terminal: a two-line terminfo fix
  - Other:
    
    buffer-terminator.el - safely auto terminate buffers for performance and reduced clutter [Release 1.2.1] (Reddit)
    
    James Cherti: buffer-guardian.el – Automatically Save Emacs Buffers Without Manual Intervention (When Buffers Lose Focus, Regularly, or After Emacs is Idle) (Reddit, Irreal)
    
    super-save 0.5: Modernized and Better Than Ever (Reddit)
    
    Much Ado About Emacs 012: kirigami, visible-mark, javelin, opml, appine, buffer-guardian, isearch-lazy-count, markdown-table-wrap, surround
    
    chaoswork/appine: embed native macOS views (WebKit, PDFKit etc.) directly inside Emacs windows. · GitHub (Reddit)
    
    emacs-os/embr.el: Emacs is the display server. Headless Chromium via CloakBrowser is the renderer. · GitHub (Reddit)
    
    Why fork+exec Takes 100ms on My Mac: Debugging Slow Emacs with Instruments (Reddit)
    
    exlee/emacs-reporter: Emacs data collector for macOS · GitHub (Reddit)
  - Emacs development:
    
    emacs-devel:
    
    Re: MacOS/NS Events Processing Queue - Przemysław Kamiński - VM compacting patch in case anyone wants to try it out
    
    Re: Tree-sitter: Correctly parsing template-like embeddings - Yuan Fu - trade-offs for performance?
    
    Re: feature/igc3 44f854bad09 2/5: Avoid remote references in face cache (analogous to bug#80601) - Eli Zaretskii - challenges with igc branch
    
    Re: some Eglot-related options to consider for newcomers-presets - João Távora - language servers and newcomers-presets?
    
    (Fmakunbound): Break aliasing, if present (bug#80538)
    
    hideshow: Fix 'hs-hide-block-behavior' set to 'after-cursor'.
    
    hideshow: New minor mode 'hs-indentation-mode'. (Bug#80179)
  - New packages:
    
    async-http-queue: Async HTTP queue with parallel fetching (MELPA)
    
    consult-symbol: Consult-based symbol search with narrowing (MELPA)
    
    flymake-zizmor: Flymake backend for zizmor, a Github Actions static analyzer (MELPA)
    
    org-snitch: Project-specific org-capture and link faces (MELPA)
    
    org-tag-cloud: Easily maintain a tag-cloud of org-mode tags (MELPA)
    
    tiles: Tagged Instant Lightweight Emacs Snippets (MELPA)
  Links from reddit.com/r/emacs, r/orgmode, r/spacemacs, Mastodon #emacs, Bluesky #emacs, Hacker News, lobste.rs, programming.dev, lemmy.world, lemmy.ml, planet.emacslife.com, YouTube, the Emacs NEWS file, Emacs Calendar, and emacs-devel. Thanks to Andrés Ramírez for emacs-devel links. Do you have an Emacs-related link or announcement? Please e-mail me at sacha@sachachua.com. Thank you!
  
  View Org source for this post
  
  You can comment on Mastodon or e-mail me at sacha@sachachua.com.
15. 🔗 r/Leeds Leeds Goes Purple! rss
  
  Starting Friday Litter Free Leeds is having its annual event where we try to get everyone involved filling purple bags with rubbish. If you want to join follow the link and find groups and events in your area.
  
  https://litterfreeleeds.co.uk/leeds-goes-purple
  
  submitted by /u/nfurnoh
  [link] [comments]
16. 🔗 r/LocalLLaMA The current state of the Chinese LLMs scene rss
  This is a summary of what's going on in Chinese LLM scene based on my own research. If you find any errors, please let me know.
  
  The Big Boys:
  1. ByteDance: dola-seed (aka doubao) is the current market leader in proprietary LLM. It plays a role like OpenAI. They have an Seed OSS 36B model that is a solid dense model but seems like no one is talking about it. They have a proprietary Seedance T2V model that is now the most popular video gen app for lay people.
  2. Alibaba - Not many people uses its properitary model Qwen Max. It is the strongest in its open weight offering especially the small models. It is also strongest in T2I and T2V scene but this is off topic.
  3. Tencent - Hunyuan is their proprietary model but not many people use. Their T2I, T2V effort is second to Alibaba. They are the leader in 3D mesh generation with Hunyuan 3D but this model is only open weight up to 2.1.
  4. Baidu - Ernie is proprietary but not many people use. Baidu is stronger in the autonomous driving scene but that's off topic here.
  5. Xiaomi - Mimo V2 Pro is their proprietary model while the Mimo V2 Flash 309B-A15B is their open weight model.
  6. Ant Group - Ling 2.5 1T is their flagship open weight model. Seems to be outperformed by Kimi K2.5, so not many people are talking about it. It introduces something called Lightning LinearAttention, does anyone know the paper describing it?
  7. RedNote - Flagship open weight model is dots.vlm1 which is a derivative of DeepSeek with vision. They also have a smaller vanilla MoE called dots.llm1 which is 142B-A14B. Seems like the performance of their models are not that impressive, so not many people are using it.
  8. Kuaishou - The lesser known domestic competitor to ByteDance in the short video space. Their focus is in coding models. Flagship is proprietary KAT-Coder-Pro-V1. They also have a 72B open weight coding model called KAT-Dev-72B-Exp. Don't know why no one is talking about it here.
  9. Meituan - LongCat-Flash-Chat is an open weight 562B model with dynamic MoE that activates 18.6B~31.3B. It also has a lite version that is 65B-A3B. Attention mechanism is MLA. Seems like they are the most aggressive open weight player now but they are more like the Middle Boy instead of Big.
  The Side Project:
  1. Deepseek - a side project from an algorithmic trading firm. Current usage in China is a close second to ByteDance's doubao with half of the users. Interestingly, it is the most innovative among all Chinese LLM companies as it invented MLA,, DSA, GRPO, etc. Please let me know if there are other non-obvious tech that is used in actual product that is developed by other Chinese companies. Their business model might be similar to the Six Small Tigers but it seems to me this project is more for attracting investments to the investment arm and gaining access to President Xi.
  The Six AI Small Tigers: (business models are highly similar. Release big open weight model to gain recognition and provide cheap inference service. Not sure if any of them is viable for the long term.)
  1. Zhipu - IPOed in HK. Current GLM-5 is a derivate of DeepSeek.
  2. Minimax - IPOed in HK. They have a MiniMax 2.7 proprietary model. MiniMax 2.5 is their open weight model which is a vanilla MoE 229B-A10B. So its inference cost is significantly lower than the others.
  3. Moonshot - Kimi open weight model which is a derivative of DeepSeek
  4. Stepfun - Step 3.5 flash is their open weight model that is a mixture of full attn and sliding window attention (SWA) layers at 1:3. It is 196B-A11B. Similar business model to Minimax but their model is not as good.
  5. Baichuan - Their Baichuan-M3 235B is a medical enhanced open weight model based on Qwen3Moe.
  6. 01 AI - Yi-34B is their last open weight model published in Nov 2024. They seem to focus on Enterprise AI agent system now, so they are becoming irrelevant to people here.
  Government Funded:
  1. Beijing Academy of AI (BAAI) - most famous for its bge embedding model. Recently started to release a DeepSeek derivative called OpenSeek-Small-v1. In general, they are not an LLM focused lab.
  2. Shanghai AI Lab - The original team was from a big facial recognition company called Sense Time. Since their LLM project was burning too much money, Sense Time founder managed to find the Chinese government to setup Shanghai AI Lab with a lot of governmental funding for the team. Their flagship is the open weight InterLM-S1-Pro. They seem to have a bad rep at Zhihu (the Chinese quora). Not many people talk about it here. Are their models any good?
  submitted by /u/Ok_Warning2146
  [link] [comments]
17. 🔗 r/LocalLLaMA Let's take a moment to appreciate the present, when this sub is still full of human content. rss
  
  It's going down guys, day by day.
  
  submitted by /u/Ok-Internal9317
  [link] [comments]
18. 🔗 r/Leeds Leeds “New Town” as part of South Bank development rss
  
  20,000 new homes, 40% to be affordable. Whilst I applaud the intent that’s a lot of houses for what is still a relatively small footprint so not really going to be the family homes needed in big blocks of high rises.
  
  But hey, at least they won’t be student lets, this time!
  
  submitted by /u/zharrt
  [link] [comments]
19. 🔗 zellij-org/zellij Release v0.44.0 release
  This is a large release including many new features, some of which long requested, as well as countless fixes, infrastructure overhauls and much more. I would like to thank everyone for their patience with this long awaited version being released. I hope you will agree it was worth the wait.
  
  Following is a non-exhaustive list of some major and significant changes:
  
  Native Windows Support
  
  Zellij now runs natively on Windows(!!). Achieved through a major community code contribution, at long last Zellij is truly multi-platform. Allowing windows users to enjoy the same session management, workspace automation, plugin ecosystem and multiplayer capabilities that have been available on Linux and macOS since the inception of the tool. We are truly excited.
  
  Special thanks to @divens for the implementation and hard work.
  
  Layout Manager
  
  This release introduces a new layout-manager interface, implemented as a built-in plugin allowing users to:
  1. Open their favorite layouts in a new tab or tabs
  2. Apply their layouts to the current tab (optionally keeping panes that do not match the layout or closing them outright)
  3. Create new layouts on the fly by recording the current tab state
  It should be noted that with the layout manager comes the new override- layout capability, appearing both a as a plugin command (used by the plugin) and as a CLI command. This capability allows us to change the layout of the current tab or all the tabs in the session to match a specific layout. An example use case for this is to toggle between the standard status-bar and the compact bar (in itself a much requested capability).
  
  To open the layout manager: Ctrl o + l
  
  Terminal-to-Terminal Attach over HTTPS (remote attach)
  
  This feature allows us to attach to a remote Zellij session (with the web server running and the session shared) from the terminal, just like we would from the browser. Using the same authentication tokens and doing so over HTTPS:
```
zellij attach https://example.com/my-cool-session
```
  Read-Only Session Sharing
  
  We are now able to issue "read-only" authentication tokens, which will allow users to attach to sessions without being able to affect them in any way (keyboard/mouse input or terminal window resizing). This can be especially useful for teaching, demonstrations, screencasting or streaming.
  
  These tokens can be issued with:
```
zellij web --create-read-only-token
```
  Or through the share plugin with Ctrl o + s
  
  CLI Automation
  
  This release dramatically expands what can be accomplished from the command line. Some main areas:
  
  Conditionally Blocking Command Panes
  
  The zellij run command now includes a --blocking, --block-until-exit- success and --block-until-exit-failure flags. Using these we can conditionally block the CLI before moving to the next command, depending on the outcome of the command run in the new pane.
  
  New CLI actions of note
  - zellij detach and zellij action switch-session
  - zellij action list-panes - lists all panes in the current or specified session, including metadata such as running commands, titles, coordinates, etc. Also optionally in --json format.
  - zellij action send-keys - allows us to send Human readable keys to a specific pane (eg. zellij action send-keys "Enter" "Ctrl c" "F1" "a" "b")
  - zellij subscribe - allows us to continuously subscribe to pane updates (viewport and scrollback) from one or more panes, optionally in --json format, optionally with --ansi (so colors and styling won't be stripped)
  - zellij action dump-screen now has a --pane-id flag so that we can query the pane viewport/scrollback actively (also from other session by prefixing the action with --session <name>)
  - CLI commands that create panes (eg. zellij run) now return the pane_id for easy storing and manipulation in following commands and scripts. CLI commands that create tabs (eg. zellij action new-tab) similarly return the created tab index.
  For more info, including examples, recipes and directions for external programmatic control, please see: https://zellij.dev/documentation/controlling-zellij-through-cli.html
  
  Resize Panes with the Mouse
  
  Panes can now be resized with the mouse. Either by dragging their borders (floating panes require ctrl + dragging, as normal dragging moves them) or by floating over the pane, holding ctrl and scrolling the mouse up or down.
  
  Note: this feature includes hints for the above keys that appear on hover. For those who do not like this behavior, the hints (as well as other mouse hover actions) can be disabled by specifying mouse_hover_effects false in the configuration.
  
  Click-to-Open File Paths
  
  By default, Zellij now highlights file paths (relative and absolute) when hovering over them with the mouse. When we Alt + Click them, these files will be opened in a new floating pane in our default EDITOR.
  
  This new capability is implemented as a built-in plugin. For those who don't like this behavior, it can be disabled by commenting out the link plugin in the configuration: https://github.com/zellij-org/zellij/blob/main/zellij- utils/assets/config/default.kdl#L249
  
  New Session Manager UI
  
  The session manager UI has been revamped and is now much simpler, including only one screen that allows user to create new sessions, attach to existing ones or resurrect exited ones - all depending on which session name is specified.
  
  For those wishing to remain with the old experience, the session manager can be run with multi_screen true.
  
  New Rust APIs
  
  It is Zellij development policy to create new UI interfaces as built-in plugins. This means that the new APIs created for all the above interfaces are now also available for third-party plugins (gated behind relevant permissions).
  These capabilities include:
  1. Read pane scrollback - Plugins can now read the scrollback buffer of other panes, optionally including the ANSI colors and styling
  2. Configuration propagation - Changes to plugin configuration are now propagated to running plugins
  3. Query environment variables - Plugins can query env vars set upon session creation
  4. Highlight viewport text - Plugins can change the style of arbitrary text in any pane's viewport, optionally on mouse hover, optionally receiving an event when the user Alt + Clicks them
  5. Change pane colors - Set foreground/background colors of panes
  6. Explicit session save - Trigger a session save for resurrection without waiting for the automatic interval
  For more info: https://zellij.dev/documentation/plugin-api.html
  
  Infrastructure Overhaul
  
  Under the hood, this release includes significant infrastructure changes:
  1. WASM runtime migration: The plugin runtime has been migrated from wasmtime to wasmi, meaning they now do not require an explicit compilation step and so do not need to be cached. This might incur a slight performance penalty for plugins, but this penalty can be almost completely mitigated by adding the following to the plugin's Cargo.toml:
    
    [profile.release] lto = true strip = true codegen-units = 1
  2. Async runtime migration: for historical reasons, up until now we've had two async runtimes: async_std and tokio. This release migrates us to use tokio exclusively.
  Forwards Compatibility
  
  Due to the lack of a client-server contract, Zellij sessions have never been backwards compatible. Each version upgrade would orphan existing sessions, forcing users to manually kill them and recreate them. While this is unfortunately still the case with this version, this will be the last time.
  
  A new client/server contract has been created and enforced with protocol buffers. Future versions will be able to connect to existing sessions. The only caveat being that new features won't work with old sessions and will silently fail.
  
  Additional Improvements
  
  Beyond the above features, this release includes a large number of bug fixes and quality-of-life improvements:
  - Borderless panes - open specific panes as borderless or toggle border status at runtime
  - Terminal BEL forwarding from unfocused tabs and panes with visual indication
  - Configurablefocus_follows_mouse and mouse_click_through
  - Line-wrapping/resize performance improvements
  - Better STDIN segmentation with latency (eg. over SSH)
  - Mobile web client viewport sizing and touch scrolling improvements
  - Numerous fixes for session resurrection, floating pane behavior, cursor handling, grid rendering and more
  For the full list of changes, see the CHANGELOG.
  
  Please Support the Zellij Developer ❤️
  
  Zellij is a labor of love and is provided free and open-source to anyone who wishes to use it.
  
  Zellij will never display ads or collect your data.
  
  To help sustain the project, please consider a recurring donation so that the developer can pay their bills: https://github.com/sponsors/imsnif
20. 🔗 r/Leeds First Direct Arena - Greg Davies rss
  
  what a fantastic night we had on Sunday 😁
  
  Greg is so damn funny, his show was on point and his warm up act, really good too.
  
  ended up sitting in the "Gods", 3 rows from the roof of the building itself. this section should have its own postcode.
  
  really tempted by the upcoming Prodigy and Carl Cox show, but will definitely buy tickets for a much lower tier!
  
  dont get me started on the price's of drinks 😮‍💨
  
  overall a fantastic night, and if you are a fan of Greg, the show is worth the cost.
  
  good job there is a Spoons nearby
  
  submitted by /u/migoodridge
  [link] [comments]
21. 🔗 backnotprop/plannotator v0.14.5 release
  Follow @plannotator on X for updates
  
  Missed recent releases? Release | Highlights
  ---|---
  v0.14.4 | GitHub review submission, repo identifier in tab title, nested code fence parser fix, Pi paste URL wiring, file header gap fix
  v0.14.3 | PR context panel, diff search in code review, OpenCode permission normalization, landing page redesign
  v0.14.2 | OpenCode plan mode prompt replacement, Windows non-ASCII path fix, Pi link fix
  v0.14.1 | Single submit_plan with auto-detect, viewed-file draft persistence, Bear nested tag fix
  v0.14.0 | PR review via GitHub URL, /plannotator-last for annotating agent messages, OpenCode plan mode permissions fix, VS Code SSH proxy fix
  v0.13.1 | OpenCode plan mode rewrite, Obsidian save fix
  v0.13.0 | Built-in themes, annotatable plan diffs, file-scoped code review comments, Octarine integration, unified review core, Pi remote sessions
  v0.12.0 | Quick annotation labels, mobile compatibility, Graphviz rendering, markdown images with lightbox, linked doc navigation in annotate mode
  v0.11.4 | Git add from code review, bidirectional scroll navigation, clipboard paste for annotation images, VS Code IPC port stability
  v0.11.3 | Expandable diff context, hierarchical folder tree, redesigned worktree controls, supply chain hardening
  v0.11.2 | Git worktree support in code review, VS Code editor annotations in review, Obsidian auto-save & separator settings, session discovery, smart file resolution
  
  What's New in v0.14.5
  
  v0.14.5 adds GitLab merge request review support, bringing Plannotator's code review UI to a second hosting platform. Two community bug fixes round out the release. 3 PRs, 2 from external contributors, 1 first-time.
  
  GitLab Merge Request Review
  
  Plannotator can now review GitLab merge requests alongside GitHub PRs. Pass any GitLab MR URL to the review command and it works the same way: diff viewer, annotations, feedback submission, and the new PR context panel (summary, comments, pipeline status).
  
  The platform is auto-detected from the URL. github.com routes through gh, and any URL containing /-/merge_requests/ routes through glab. Self-hosted GitLab instances are supported via the --hostname flag.
  
  Under the hood, the existing GitHub implementation was extracted to packages/shared/pr-github.ts, and a parallel pr-gitlab.ts handles glab CLI interactions. The dispatch layer in pr-provider.ts routes by platform. The PRRef and PRMetadata types are now discriminated unions that carry the platform context throughout the stack.
  
  GitLab's API surface differs from GitHub's in several ways that required specific handling. glab mr diff outputs bare diffs without the diff --git prefix, so the output is normalized before parsing. glab has no --jq flag, so JSON responses are parsed in full. Review submission requires three separate API calls (note, discussions, approve) rather than GitHub's single atomic endpoint, with inline comments submitted in parallel using Promise.allSettled for partial failure resilience.
  
  The UI adapts to the platform: labels switch between PR/MR, icons between GitHub/GitLab, and issue number prefixes between # and !.
  - #364
  Annotate-Last Session Resolution After cd
  
  /plannotator-last silently annotated the wrong message when a user changed directories during a Claude Code session. The command resolves the current session by matching process.cwd() against Claude Code's project slug, but after a cd the CWD no longer matches the session's original directory. The result: it finds a stale session from a previous day and opens that session's last message with no warning.
  
  The fix introduces three-tier session resolution. First, it checks for PPID- based session metadata that Claude Code writes to ~/.claude/sessions/. If that's not available, it falls back to CWD-based slug matching, then to a recency heuristic. The PPID path is the most reliable because it ties directly to the running Claude Code process regardless of the shell's current directory.
  
  This is a Claude Code-only bug. Codex uses CODEX_THREAD_ID, OpenCode and Pi use their SDK APIs, and none of them resolve sessions via CWD.
  - #366 by @janah01
  Additional Changes
  - Fix duplicate Code Review header in Pi extension — the Pi extension's review command handler wrapped feedback in a # Code Review Feedback heading, but exportReviewFeedback() already includes that heading. The duplicate is removed, and two tests verify single-heading output. By @dmmulroy in #370.
  Install / Update
  
  macOS / Linux:
```
curl -fsSL https://plannotator.ai/install.sh | bash
```
  Windows:
```
irm https://plannotator.ai/install.ps1 | iex
```
  Claude Code Plugin: Run /plugin in Claude Code, find plannotator , and click "Update now".
  
  OpenCode: Clear cache and restart:
```
rm -rf ~/.bun/install/cache/@plannotator
```
  Then in opencode.json:
```
{
  "plugin": ["@plannotator/opencode@latest"]
}
```
  Pi: Install or update the extension:
```
pi install npm:@plannotator/pi-extension
```
  What's Changed
  - feat: GitLab merge request review support by @backnotprop in #364
  - fix: annotate-last resolves wrong session after cd by @janah01 in #366
  - fix: remove duplicate 'Code Review' header in pi extension review feedback by @dmmulroy in #370
  New Contributors
  - @janah01 made their first contribution in #366
  Contributors
  
  @janah01 identified and fixed a subtle session resolution bug in /plannotator-last that caused it to silently annotate the wrong message after cd-ing during a Claude Code session. The three-tier resolution strategy in #366 ensures the command finds the correct session regardless of the shell's current directory.
  
  @dmmulroy fixed the duplicate heading in Pi extension review feedback in #370, his second contribution after wiring the paste URL in v0.14.4.
  
  Full Changelog : v0.14.4...v0.14.5
22. 🔗 r/reverseengineering /r/ReverseEngineering's Weekly Questions Thread rss
  
  To reduce the amount of noise from questions, we have disabled self-posts in favor of a unified questions thread every week. Feel free to ask any question about reverse engineering here. If your question is about how to use a specific tool, or is specific to some particular target, you will have better luck on the Reverse Engineering StackExchange. See also /r/AskReverseEngineering.
  
  submitted by /u/AutoModerator
  [link] [comments]
23. 🔗 r/LocalLLaMA So cursor admits that Kimi K2.5 is the best open source model rss
  
  | Nothing speaks louder than recognition from your peers. submitted by /u/Giveawayforusa
  [link] [comments]
  ---|---
24. 🔗 r/LocalLLaMA I came from Data Engineering stuff before jumping into LLM stuff, i am surprised that many people in this space never heard Elastic/OpenSearch rss
  
  | Jokes aside, on a technical level, Google/brave search and vector stores basically work in a very similar way. The main difference is scale. From an LLM point of view, both fall under RAG. You can even ignore embedding models entirely and just use TF-IDF or BM25. Elastic and OpenSearch (and technically Lucene) are powerhouses when it comes to this kind of retrieval. You can also enable a small BERT model as a vector embedding, around 100 MB (FP32), running in on CPU, within either Elastic or OpenSearch. If your document set is relatively small (under ~10K) and has good variance, a small BERT model can handle the task well, or you can even skip embeddings entirely. For deeper semantic similarity or closely related documents, more powerful embedding models are usually the go to. submitted by /u/Altruistic_Heat_9531
  [link] [comments]
  ---|---
March 22, 2026
1. 🔗 IDA Plugin Updates IDA Plugin Updates on 2026-03-22 rss
  IDA Plugin Updates on 2026-03-22
  
  Activity:
  - dylib_dobby_hook
    
    ca090048: Refactor memory utility calls to use macros for instance variable acc…
  - tomsons_RE_scripts
    
    a0d9cd4a: update specific_dyn_init_namer.py
2. 🔗 Simon Willison Experimenting with Starlette 1.0 with Claude skills rss
  Starlette 1.0 is out! This is a really big deal. I think Starlette may be the Python framework with the most usage compared to its relatively low brand recognition because Starlette is the foundation of FastAPI, which has attracted a huge amount of buzz that seems to have overshadowed Starlette itself.
  
  Kim Christie started working on Starlette in 2018 and it quickly became my favorite out of the new breed of Python ASGI frameworks. The only reason I didn't use it as the basis for my own Datasette project was that it didn't yet promise stability, and I was determined to provide a stable API for Datasette's own plugins... albeit I still haven't been brave enough to ship my own 1.0 release (after 26 alphas and counting)!
  
  Then in September 2025 Marcelo Trylesinski announced that Starlette and Uvicorn were transferring to their GitHub account, in recognition of their many years of contributions and to make it easier for them to receive sponsorship against those projects.
  
  The 1.0 version has a few breaking changes compared to the 0.x series, described in the release notes for 1.0.0rc1 that came out in February.
  
  The most notable of these is a change to how code runs on startup and shutdown. Previously that was handled by on_startup and on_shutdown parameters, but the new system uses a neat lifespan mechanism instead based around an async context manager:
```
@contextlib.asynccontextmanager
async def lifespan(app):
    async with some_async_resource():
        print("Run at startup!")
        yield
        print("Run on shutdown!")

app = Starlette(
    routes=routes,
    lifespan=lifespan
)
```
  If you haven't tried Starlette before it feels to me like an asyncio-native cross between Flask and Django, unsurprising since creator Kim Christie is also responsible for Django REST Framework. Crucially, this means you can write most apps as a single Python file, Flask style.
  
  This makes it really easy for LLMs to spit out a working Starlette app from a single prompt.
  
  There's just one problem there: if 1.0 breaks compatibility with the Starlette code that the models have been trained on, how can we have them generate code that works with 1.0?
  
  I decided to see if I could get this working with a Skill.
  
  Building a Skill with Claude
  
  Regular Claude Chat on claude.ai has skills, and one of those default skills is the skill-creator skill. This means Claude knows how to build its own skills.
  
  So I started a chat session and told it:
  
  Clone Starlette from GitHub - it just had its 1.0 release. Build a skill markdown document for this release which includes code examples of every feature.
  
  I didn't even tell it where to find the repo, Starlette is widely enough known that I expected it could find it on its own.
  
  It ran git clone https://github.com/encode/starlette.git which is actually the old repository name, but GitHub handles redirects automatically so this worked just fine.
  
  The resulting skill document looked very thorough to me... and then I noticed a new button at the top I hadn't seen before labelled "Copy to your skills". So I clicked it:
  
  And now my regular Claude chat has access to that skill!
  
  A task management demo app
  
  I started a new conversation and prompted:
  
  Build a task management app with Starlette, it should have projects and tasks and comments and labels
  
  And Claude did exactly that, producing a simple GitHub Issues clone using Starlette 1.0, a SQLite database (via aiosqlite) and a Jinja2 template.
  
  Claude even tested the app manually like this:
  cd /home/claude/taskflow && timeout 5 python -c " import asyncio from database import init_db asyncio.run(init_db()) print('DB initialized successfully') " 2>&1 pip install httpx --break-system-packages -q \ && cd /home/claude/taskflow && \ python -c " from starlette.testclient import TestClient from main import app client = TestClient(app) r = client.get('/api/stats') print('Stats:', r.json()) r = client.get('/api/projects') print('Projects:', len(r.json()), 'found') r = client.get('/api/tasks') print('Tasks:', len(r.json()), 'found') r = client.get('/api/labels') print('Labels:', len(r.json()), 'found') r = client.get('/api/tasks/1') t = r.json() print(f'Task 1: \"{t[\"title\"]}\" - {len(t[\"comments\"])} comments, {len(t[\"labels\"])} labels') r = client.post('/api/tasks', json={'title':'Test task','project_id':1,'priority':'high','label_ids':[1,2]}) print('Created task:', r.status_code, r.json()['title']) r = client.post('/api/comments', json={'task_id':1,'content':'Test comment'}) print('Created comment:', r.status_code) r = client.get('/') print('Homepage:', r.status_code, '- length:', len(r.text)) print('\nAll tests passed!') "
  For all of the buzz about Claude Code, it's easy to overlook that Claude itself counts as a coding agent now, fully able to both write and then test the code that it is writing.
  
  Here's what the resulting app looked like. The code is here in my research repository.
  
  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.
3. 🔗 r/Leeds Looking for physical signage of the place name "Steander" in the LS9 area rss
  
  In a random stroke of inspiration, I've gotten myself fascinated with the old forgotten Steander/Fearns Island area across the river from the Armouries. I've been out in the area trying to find any sort of signage or mention of the name "Steander". So far the only mention of it I've seen is on the map at the dock showing the area as it was in the 1930s, but that's it. I know it used to be on the street signs in the area, but those were unfortunately far before my time.
  
  I'm throwing this out there to ask if anybody knows if the name is present anywhere physically in the area that's still presently there? Any help would be much appreciated :)
  
  submitted by /u/SH_Eastawott
  [link] [comments]
4. 🔗 r/Yorkshire Between Skipton, Gargrave and Airton 🚶 rss
  
  | submitted by /u/unitedkingdombaby
  [link] [comments]
  ---|---
5. 🔗 r/Harrogate Slingsby Gin rss
  
  Visiting Harrogate from out of town and would like to take a few bottles of Slingsby gin back home for a friend. Any idea where it can still be purchased?
  
  submitted by /u/Apprehensive_Pay_740
  [link] [comments]
6. 🔗 r/reverseengineering Reversing World Conqueror 4's asset encryption — AES-256-CBC with 5 header variants, key extracted from .so rss
  
  submitted by /u/Ascendo_Aquila
  [link] [comments]
7. 🔗 r/york Best camping sites in Yorkshire area? rss
  
  submitted by /u/Ill-Toe-8182
  [link] [comments]
8. 🔗 r/Yorkshire Campaigners celebrate reprieve for Whitby cliff lift rss
  
  | Campaigners in Whitby are celebrating after North Yorkshire Council backed a motion to investigate the costs of repairing the town's historic cliff lift rather than permanently closing it. The 95-year-old attraction has been out of action for three years, prompting a petition with over 5,600 signatures to save it. A report presented to North Yorkshire Council's executive yesterday recommended permanently closing the 95-year-old lift, which has been out of action for three years since corrosion was discovered in 2022. Council officers had initially recommended adopting a £199,000 plan to seal the lift shaft while retaining the top building, arguing that full repairs, estimated to cost up to £5.5 million, were disproportionate in a challenging financial environment. However, councillors have instead backed a motion to look into the costs of repairing the lift, following fierce resistance from residents and a petition to save the historic landmark that gathered more than 5,600 signatures. submitted by /u/coffeewalnut08
  [link] [comments]
  ---|---
9. 🔗 r/Yorkshire Mayor unveils £1.5bn ‘People’s Network’ transport plan for South Yorkshire rss
  
  | Mayor unveils £1.5bn ‘People’s Network’ transport plan for South Yorkshire Trams, buses and hire bikes will be integrated under molten orange and asphalt black livery highlighting industrial heritage, says Oliver Coppard South Yorkshire’s transport system will be known as the “People’s Network”, with trams, buses and hire bikes all coming under public control. The plan was unveiled on Monday by the region’s mayor, Oliver Coppard, who said it would create an affordable, joined-up network in molten orange and asphalt black colours. A large fleet of electric buses and 25 new trams will be introduced over the next five years. Buses will be franchised and taken under public control next year, joining the Supertram, which was brought back into the combined authority’s hands in 2024. Coppard said it was a “once-in-a-generation change to how transport works in South Yorkshire”. submitted by /u/coffeewalnut08
  [link] [comments]
  ---|---
10. 🔗 r/LocalLLaMA Alibaba confirms they are committed to continuously open-sourcing new Qwen and Wan models rss
  
  | Source: https://x.com/ModelScope2022/status/2035652120729563290 submitted by /u/TKGaming_11
  [link] [comments]
  ---|---
11. 🔗 r/LocalLLaMA MiniMax M2.7 Will Be Open Weights rss
  
  | Composer 2-Flash has been saved! (For legal reasons that's a joke) submitted by /u/Few_Painter_5588
  [link] [comments]
  ---|---
12. 🔗 r/LocalLLaMA Impressive thread from /r/ChatGPT, where after ChatGPT finds out no 7Zip, tar, py7zr, apt-get, Internet, it just manually parsed and unzipped from hex data of the .7z file. What model + prompts would be able to do this? rss
  
  | submitted by /u/jinnyjuice
  [link] [comments]
  ---|---
13. 🔗 r/Yorkshire Looking upstream on the Swale towards Culloden tower yesterday. rss
  
  | submitted by /u/Still_Function_5428
  [link] [comments]
  ---|---
14. 🔗 3Blue1Brown (YouTube) This picture broke my brain rss
  
  Escher's Print Gallery, and the tour of complex analysis it invites. Check out our virtual career fair: 3b1b.co/talent Join channel supporters to see videos early: 3b1b.co/support An equally valuable form of support is to share the videos. Home page: https://www.3blue1brown.com
  
  Original paper by de Smit and Lenstra: https://pub.math.leidenuniv.nl/~smitbde/papers/2003-de_smit-lenstra-escher.pdf
  
  Co-written by Paul Dancstep, who handled many of the animations in the art section, including the delightful mesh warp scene.
  
  Aaron Gostein helped with the manim animations in the section introducing complex functions.
  
  Artwork provided by Talia Gerhson, Mitchell Zemil, and Anna Fedczuk.
  
  Music by Vincent Rubinetti
  
  Timestamps:
  
  0:00 - The print gallery 13:04 - Conformal maps from complex analysis 21:41 - The complex exponential 25:56 - The complex logarithm 32:32 - 3b1b Talent 33:14 - Constructing the key function 40:16 - The deeper math behind Escher
  
  These animations are largely made using a custom Python library, manim. See the FAQ comments here: https://3b1b.co/faq#manim
  
  3blue1brown is a channel about animating math, in all senses of the word animate. If you're reading the bottom of a video description, I'm guessing you're more interested than the average viewer in lessons here. It would mean a lot to me if you chose to stay up to date on new ones, either by subscribing here on YouTube or otherwise following on whichever platform below you check most regularly.
  
  Mailing list: https://3blue1brown.substack.com Twitter: https://twitter.com/3blue1brown Bluesky: https://bsky.app/profile/3blue1brown.com Instagram: https://www.instagram.com/3blue1brown Reddit: https://www.reddit.com/r/3blue1brown Facebook: https://www.facebook.com/3blue1brown Patreon: https://patreon.com/3blue1brown Website: https://www.3blue1brown.com
15. 🔗 r/reverseengineering I built a tool to search and extract specific classes from very large JAR files rss
  
  submitted by /u/ProphetC8
  [link] [comments]
16. 🔗 r/Harrogate Vegetarian Fish & Chips rss
  
  for anyone know of any Fish & Chip places in Harrogate that don‘t fry their chips in beef dripping?
  
  submitted by /u/CyclePrevious9043
  [link] [comments]
17. 🔗 r/york 2 Day York Itinerary rss
  
  My husband and I are visiting York in a couple of weeks and I’ve put together the following itinerary: (yes I like planning as terrible at decision making 🫠)
  
  Is there anything you would add / change? We are in our late 30s and like art, history, food and beers/cocktails.
  
  Wednesday
  
  Breakfast - Brew & Brownie
  
  Morning - York Art gallery , Look at York Minster , City Walls,
  
  Lunch - Shambles Area/Market
  
  Afternoon - Cat walking trail
  
  Cocktails: Dusk / Polymath
  
  Dinner - Dough Eyes
  
  Evening Pub crawl - Valhalla, Shambles Tavern, house of trembling, the Golden Fleece
  
  Thursday
  
  Breakfast : Flori Bakery
  
  Morning: York Castle Musuem , Clifford’s Tower, Fairfax House
  
  Lunch: Brew York
  
  Cake: Little Blondie Bakehouse
  
  Afternoon : York Distillery Gin Tasting
  
  Pre dinner drink - Cat in the Wall
  
  Dinner: Rustique
  
  submitted by /u/Iamtheonlylauren
  [link] [comments]
18. 🔗 r/Leeds New station clock looks tacky rss
  
  Not a fan at all
  
  submitted by /u/AlanWrightScreamer
  [link] [comments]
19. 🔗 r/york Can anybody suggest a decent window cleaner in York? rss
  
  submitted by /u/OneItchy396
  [link] [comments]
20. 🔗 r/Leeds Lane Side development in Churwell losing planned school for 250 more homes – anyone else worried about local infrastructure? rss
  
  I recently visited the Lane Side development in Churwell and found out that the land originally reserved for a school is apparently no longer going to be used for one. From what I haveen told that Leeds City Council believes the existing schools in the area are enough to absorb the extra demand from new residents, and the developer is instead being allowed to build around 250 more homes under Charles Church. Honestly, I find this really worrying. There is already a huge amount of development happening around here, and it feels like social infrastructure is not keeping up at all. Schools, GP surgeries, and local roads are already under pressure, and Elland Road is busy enough as it is. Is anyone else concerned about how all this extra housing is being approved without proper supporting infrastructure in place?
  
  submitted by /u/Historical-Turn8243
  [link] [comments]
21. 🔗 r/LocalLLaMA Qwen3.5-9B-Claude-4.6-Opus-Uncensored-v2-Q4_K_M-GGUF rss
  This is a request merge asked by some people on Reddit and HuggingFace. They don't have powerful GPUs and want to have big context window in uncensored smart local AI.
  
  NEW: So, during tensor debugging session via merging I found a problem. In GGUF files some attention layers and expert layers (29 total) are mathematically broken during GGUF convertation from original .safetensors to .gguf.
  
  Fixed Q3_K_M, Q4_K_M, Q8_0, quants for HauhauCS Qwen 3.5 35B-A3B original model uploaded:
  I am using Q4_K_M quant. I have 16 tokens per second on RTX 3060 12 GB.
  https://huggingface.co/LuffyTheFox/Qwen3.5-35B-A3B-Uncensored-HauhauCS- Kullback- Leibler
  
  9B model in Q4_K_M format available here.
  Сurrently the most stable KL quant for Qwen 3.5 9B, but still has thinking loops:
  https://huggingface.co/LuffyTheFox/Qwen3.5-9B-Claude-4.6-Opus-Uncensored- Kullback-Leibler
  
  For both models for best perfomance please use following settings in LM Studio 0.4.7 (build 4):
  1. Use this System Prompt: https://pastebin.com/pU25DVnB
  2. If you want to disable thinking use this chat template in LM Studio: https://pastebin.com/uk9ZkxCR
  3. Temperature: 0.7
  4. Top K Sampling: 20
  5. Repeat Penalty: (disabled) or 1.0
  6. Presence Penalty: 1.5
  7. Top P Sampling: 0.8
  8. Min P Sampling: 0.0
  9. Seed: 3407
  BONUS: Dataset for System Prompt written by Claude Opus 4.6: https://pastebin.com/9jcjqCTu
  
  Finally found a way to merge this amazing model made by Jackrong: https://huggingface.co/Jackrong/Qwen3.5-9B-Claude-4.6-Opus-Reasoning- Distilled-v2-GGUF
  
  With this uncensored model made by HauhauCS: https://huggingface.co/HauhauCS/Qwen3.5-9B-Uncensored-HauhauCS-Aggressive
  
  And preserve all training data and accuracy on Qwen 3.5 9B architecture for weights in tensors via Float32 precision during merging process. I simply pick Q8 quant, dequant it in Float32, merge float32, and re-quantize float32 back to Q4_K_M via llama-quantize binary file from llama.cpp.
  
  Now we have, the smallest, fastest and the smartest uncensored model trained on this dataset: https://huggingface.co/datasets/Roman1111111/claude- opus-4.6-10000x
  
  On my RTX 3060 I got 42 tokens per second in LM Studio. On, llama-server it can run even more faster.
  
  Enjoy, and share your results ^_^. Don't forget to upvote / repost so more people will test it.
  
  PS: There were a lot of questions according to math troubles during merging process in GGUF format. Yes, the most mathematiclly correct way is using .safetensors format in float16 for merging neural networks together. Q8 -> Float32 (merge per tensor) -> Q8. Сonversion in GGUF is a workaround, but it's a best that I can currently do during to very limted system resources.
  
  submitted by /u/EvilEnginer
  [link] [comments]
22. 🔗 r/Yorkshire West Yorkshire makes the case: Mayor Tracy Brabin calls for a rethink on Brexit to unlock regional growth rss
  
  | submitted by /u/johnsmithoncemore
  [link] [comments]
  ---|---
23. 🔗 Register Spill Joy & Curiosity #79 rss
  Is software turning into a liquid?
  
  It never was a solid, true. Pure thought stuff, as Fred Brooks wrote. But even that pure thought stuff felt more tangible than what software is turning into, did it not? Software had corners and edges: releases and version numbers. This is a piece of software, it's done, one could say. A long time ago, software even came in boxes. Sometimes it had a printed manual.
  
  Now ChatGPT writes tens or hundreds of lines of Python to resize images, create a PDF, or extract data from a CSV -- and then throws it away, without anyone even having seen the code. An agent like OpenClaw will create a little script to check whether I turned off all the lights in the house. Nothing to throw away, because it was never stored in a file.
  
  There is now so much code out there, appearing and disappearing as needed, that putting version numbers on it seems as futile as naming waves in the ocean.
  
  Is this what most software is going to be? Nameless, shapeless? Created just in time?
  
  A good friend of mine works at a company that shoots into and operates things in space. This week he told me that they're required to record how much torque they use to tighten bolts and screws. There are torque-recording wrenches you can buy, but they cost $25k a pop. Maybe it was $15k, not sure, but it was an outrageous number. So outrageous that someone on his team thought "nuh-uh" and went out and bought Bluetooth-enabled torque wrenches for $1k -- far cheaper in this comparison. Then that teammate, who's not a programmer, used an agent to vibe-code a piece of software to talk to the torque wrenches via Bluetooth and record the data in the spreadsheet he uses. He tested it a few times to make sure it worked as it should and then, well, went to work. Tens of thousands of dollars saved.
  
  Now that was a piece of software , right? One could even put a name on it: TorqueThis v0.0.1, or something. But I said to my friend, one could also imagine that in the future, say in a year, even that won't be a piece anymore. Doesn't it seem possible that in a year you can say to your agent: hey, I'm holding this Bluetooth-enabled torque wrench in my hand, I have this spreadsheet open, write some code that records the torque whenever I say "now" and adds it as a new row in column D of that spreadsheet.
  
  And code will appear, do its things while you do your thing, and then it'll disappear. Drip drip drip, it goes into every nook and cranny and then, job done, it evaporates.
  - Are you going to be in Boston in July? Let's meet at Laracon. I'll be speaking there.
  - Adapting to AI: Reflections on Productivity. One of the calmest, most balanced, and most pragmatic pieces of writing I've seen on this topic. It has more questions than answers, but that feels apt for what we're going through. I'm skeptical of any opinion about programming these days if it's made up of more exclamation marks than question marks.
  - I'd never read anything by C.S. Lewis, but whenever I came across his name I felt like I should have. This week, I finally righted what had long felt like a wrong and read The Inner Ring. And now I want more: "The quest of the Inner Ring will break your hearts unless you break it. But if you break it, a surprising result will follow. If in your working hours you make the work your end, you will presently find yourself all unawares inside the only circle in your profession that really matters. You will be one of the sound craftsmen, and other sound craftsmen will know it. This group of craftsmen will by no means coincide with the Inner Ring or the Important People or the People in the Know. It will not shape that professional policy or work up that professional influence which fights for the profession as a whole against the public: nor will it lead to those periodic scandals and crises which the Inner Ring produces. But it will do those things which that profession exists to do and will in the long run be responsible for all the respect which that profession in fact enjoys and which the speeches and advertisements cannot maintain."
  - To the sound of "Is this the real life? Is this just fantasy?" from Queen's Bohemian Rhapsody: "European Commission […] announced the creation of a '28th regime' […] The Proposal for an EU Inc. corporate legal framework provides faster (within 48 hours), cheaper (maximum EUR 100) and fully digital company registration, simplified procedures throughout the company life cycle, easier digital share transfers and capital operations, support for modern financing instruments, and the possibility for Member States to allow access to public equity markets. It also introduces fully digital insolvency procedures and automatic transmission of company data to relevant authorities in line with the "once-only principle," while including safeguards against fraud and abuse." If this truly, actually, for real happens then something that has died in me through the process of running a company here in Germany will maybe be reborn again.
  - The always wonderful Craig Mod: "The point of bloviating like this: We watch the LLMs perform these acts -- acts that, even five years ago, would have seemed like pure science fiction -- and we wrongly (I believe) extrapolate out a kind of intelligence that would be able to make sound decisions on a larger, world-based scale. Which is to say: LLMs' operating resolution is severely hamstrung. Whereas we, humans -- messy, disgusting, goopy, flawed, miraculous humans -- are operating at a freakishly high resolution, to which we have a preternatural ability to access subconsciously, and through which we use language to represent -- in broad strokes -- notions that operate in this higher register."
  - This was a delicious mind-bender: CEOs Don't Steer. It only made my fascination with businesses greater.
  - The Guardian profiled Stewart Brand and I thought it was lovely. I've never before looked through the notion of Maintenance as a lense like this.
  - Agent-Native Engineering by the The General Intelligence Company Of New York. There's a bunch of interesting stuff in there (although I bet it's not as applicable as it sounds) but this one here stood out: "Speaking of idea generation, that's the new problem. Before 2026 engineers had to spend time using their high level of intelligence solving relatively narrow well defined problems. Now, most of those problems are simple or manageable by background agents. Your engineers' new job is to find more problems to solve. That's why many are saying its the golden age of the idea guy - it is. If you can narrowly scope a problem then hand it off to an engineer, you might as well just hand it off to a background agent."
  - Ghostling: "A minimum viable terminal emulator built on top of the libghostty C API." Mitchell added: "From empty repo to a functional minimal standalone terminal based on libghostty in 2 hours, presenting Ghostling! ~600 lines of C and you get extremely accurate, performant, and proven terminal emulation." And someone asked: "Did you use AI? I'm wondering because you pushed this out pretty quickly and there is a large volume of comments... but the code is neat and readable" And he said: "I didn't write a single line of code. I reviewed it all though and consistently nudged the AI in the right direction. Heavy commenting is my personal style, and its especially good for a demo like this."
  - This is pretty neat: Obsidian Web Clipper now comes with a "reader mode" (I don't know if that's the official name) that produces pretty good results and is incredibly fast. Lot of fun to press Opt-Shift-R and see what it does.
  - Now, this, this was interesting: We Have Learned Nothing. I mean, they had me at Thomas Kuhn and Paul Feyerabend (although it felt like they really wanted to throw those names in there even if they didn't have to), but the Red Queen was the interesting bit: "In 1973, the evolutionary biologist Leigh Van Valen proposed what he called the Red Queen hypothesis: in any ecosystem, when one species evolves an advantage at the expense of another, the disadvantaged species will evolve to offset that improvement. […] Similarly, when new startup methods are quickly adopted by everyone, no one gains a relative advantage, and success rates stay flat. To win, startups must develop novel, differentiating strategies and build sustainable barriers to imitation before competitors can catch up."
  - I consider myself a pretty advanced User of Computers. An experienced Surfer of the Web, so to say. Someone who never, even back in 2000, fell prey to the flashy, blinking, red Download button that would appear on websites to trick you when you were trying to download something real. Pour two drinks into me and I'll even insist that I never, not once, not a single time in my life, clicked on something I didn't mean to click on. If I clicked, I meant to click. And I never clicked on a fake link, yes sir. I'm that good with the cursor. But, fucking hell, I think I would've fallen for this phishing attack.
  - The 49MB Web Page. I don't get people who truly enjoy horror movies. Like, you get a kick out of being scared, of … feeling bad? And yet here I am, reading about 49MB web pages, shivering, shaking my head.
  - Matteo Collina wrote about why Node.js needs a virtual file system and the two paragraphs that made everyone share this: "What began as a holiday experiment became PR #61478: a node:vfs module for Node.js, with almost 14,000 lines of code across 66 files. Let me be honest: a PR that size would normally take months of full-time work. This one happened because I built it with Claude Code. I pointed the AI at the tedious parts, the stuff that makes a 14k-line PR possible but no human wants to hand-write: implementing every fs method variant (sync, callback, promises), wiring up test coverage, and generating docs. I focused on the architecture, the API design, and reviewing every line. Without AI, this would not have been a holiday side project. It just wouldn't have happened."
  - The Robotic Tortoise & the Robotic Hare. It's a race between Opus 4.6 and Qwen 35B, the latter running locally and with less, say, smarts. But Qwen won. Because: "With 3x faster responses, I could add an extra cycle : 'critique the plan and address the critiques.' In the time the hare was still thinking, the tortoise ran another lap." Very interesting! I'm torn on this. At some point last year I was also a believer in "if you have a dumb but fast model, it can outrun the smart but slow model" but then, in practice, it turns out that on average the smart but slow model is actually fast, because -- on average -- it gets to the right results faster. Maybe that's changing? Maybe the floor has been raised too and "dumb" models are smart enough now?
  - "A skill file based on the articles written on my personal site. Designed for designers and engineers to help them build better user interfaces." What a time to be alive! A file as a distillation of one's own preferences and taste and judgement and experiences, fed to a neural network trained to help you get your work done.
  - macOS has /usr/bin/time which takes an -l argument and can show memory & resource usage of whatever command you're passing.
  - apenwarr: Every layer of review makes you 10x slower. In some sense, I get it. Yes. Reviews can be the bottleneck. But then: are reviews the same thing they were three years ago? Does a review take the same amount of time, no: should it take the same amount of time as in 2023, even if you can now spin up five parallel models to help you review? (And this one I'm consciously putting in parentheses so you can imagine I whisper this into your ear: I also don't think that in the near future the code generated by models will need close-up reviews.)
  - Can't say I've ever been really interested in Banksy, but this was great: In Search of Banksy.
  - A sufficiently detailed spec is code. I'm not sure what to think here. On one hand: yes, true, if you want to specify everything a piece of software is supposed to do, you might as well write the code. On the other: it also feels like you can specify what software is supposed to do without being 100% precise and, as long as the person (thing) implementing it and you have some shared understanding about what's left out of the spec, things will be fine. Question is how much shared understanding there is and I think that's where a lot of people have the wrong estimates.
  - tigerfs looks very, very interesting: "A filesystem backed by PostgreSQL, and a filesystem interface to PostgreSQL. TigerFS mounts a database as a directory. Every file is a real row. Writes are transactions. Multiple agents and humans can read and write concurrently with full ACID guarantees, locally or across machines. Any tool that works with files works out of the box." I've been hacking on an agent that isn't really stateless but also doesn't need a full VM. A filesystem backed by PostgreSQL seems like it sits right in the middle and could be very handy.
  - Armin: "There's a feeling that all the things that create friction in your life should be automated away. That human involvement should be replaced by AI-based decision-making. Because it is the friction of the process that is the problem. When in fact many times the friction, or that things just take time, is precisely the point."
  - Pre-ordered this within ten seconds of clicking the link: "Silicon is the element that built modernity. Silicon is a beautiful book about the world of transistors, chips, and the greatest technology revolution of all time." Of course, right after I caught myself: wait, did you just pre-order an expensive book about… silicon? Yes, I did. Let's see how it goes.
  - Talking about Silicon: there's a new Dwarkesh episode with Dylan Patel out. I love it. Listening to this made me think: is this how people how are into sports feel like every weekend?
  - Then again, I do know what it's like to be into sports, don't I? Yesterday evening I put on this thriller (top comment: "The heavy breathing of two very experienced commentators tells you how special this achievement is!") and my wife couldn't make sense of the dichotomy between the quiet click-clacks coming from the TV and me saying "holy shit, holy shit, now he's going to put the white-- wow, incredible."
  Ever spent a Sunday evening in front of the TV, alone, dreading going to to school the next day, thinking "maybe I should become a snooker player? never played once in my life, but everyone has to start somewhere, don't they?" Then you should subscribe:
24. 🔗 HexRaysSA/plugin-repository commits sync repo: +1 release rss
```
sync repo: +1 release

## New releases
- [IDAssistMCP](https://github.com/symgraph/IDAssistMCP): 1.3.0
```
25. 🔗 r/reverseengineering Hyoketsu - Solving the Vendor Dependency Problem in Reverse Engineering rss
  
  submitted by /u/Mempodipper
  [link] [comments]
26. 🔗 r/LocalLLaMA Interesting loop rss
  
  | submitted by /u/Willing_Reflection57
  [link] [comments]
  ---|---
27. 🔗 r/Leeds Meant to be going on a date in Leeds but he cancelled. rss
  
  It's super hard for me to get a day off work and I normally drive every where however like an idiot I've booked the day off and booked the train and hotel only to be cancelled on.. Rather than not going, what is there to do in Leeds on Thursdays?
  
  submitted by /u/throwradrpri
  [link] [comments]
28. 🔗 Baby Steps Maximally minimal view types, a follow-up rss
  A short post to catalog two interesting suggestions that came in from my previous post, and some other related musings.
  
  Syntax with .
  
  It was suggested to me via email that we could use . to eliminate the syntax ambiguity:
```
let place = &mut self.{statistics};
```
  Conceivably we could do this for the type, like:
```
fn method(
    mp: &mut MessageProcessor.{statistics},
    ...
)
```
  and in self position:
```
fn foo(&mut self.{statistics}) {}
```
  I have to sit with it but…I kinda like it?
  
  I'll use it in the next example to try it on for size.
  
  Coercion for calling public methods that name private types
  
  In my post I said that if you hvae a public method whose self type references private fields, you would not be able to call it from another scope:
```
mod module {
    #[derive(Default)]
    pub struct MessageProcessor {
        messages: Vec<String>,
        statistics: Statistics,
    }

    pub struct Statistics { .. }

    impl MessageProcessor {
        pub fn push_message(
            &mut self.{messages},
            //         -------- private field
            message: String,
        ) {}
    }
}

pub fn main() {
    let mp = MessageProcessor::default();
    mp.push_message(format!("Hi"));
    // ------------ Error!
}
```
  The error arises from desugaring push_message to a call that references private fields:
```
MessageProcessor::push_message(
    &mut mp.{messages},
    //       -------- not nameable here
    format!("Hi"),
)
```
  I proposed we could lint to avoid this situation.
  
  But an alternative was proposed where we would say that, when we introduce an auto-ref, if the callee references local variables not visible from this point in the program, we just borrow the entire struct rather than borrowing specific fields.
  
  So then we would desugar to:
```
MessageProcessor::push_message(
    &mut mp,
    //   -- borrow the whole struct
    format!("Hi"),
)
```
  If we then say that &mut MessageProcessor is coercable to a &mut MessageProcessor.{messages}, then the call would be legal.
  
  Interestingly, the autoderef loop already considers visibility: if you do a.foo, we will deref until we see a foo field visible to you at the current point.
  
  Oh and a side note, assigning etc
  
  This raises an interesting question I did not discuss. What happens when you write a value of a type like MessageProcessor.{messages}?
  
  For example, what if I do this:
```
fn swap_fields(
    mp1: &mut MessageProcessor.{messages},
    mp2: &mut MessageProcessor.{messages},
) {
    std::mem::swap(mp1, mp2);
}
```
  What I expect is that this would just swap the selected fields (messages, in this case) and leave the other fields untouched.
  
  The basic idea is that a type MessageProcessor.{messages} indicates that the messages field is initialized and accessible and the other fields must be completely ignored.
  
  Another possible future extension: moved values
  
  This represents another possible future extension. Today if you move out of a field in a struct, then you can no longer work with the value as a whole:
```
impl MessageProcessor {
    fn example(mut self) {
        // move from self.statistics
        std::mem::drop(self.statistics);

        // now I cannot call this method,
        // because I can't borrow `self`:
        self.push_message(format!("Hi again"));
    }
}
```
  But with selective borrowing, we could allow this, and you could even return "partially initialized" values:
```
impl MessageProcessor {
    fn take_statistics(
        mut self,
    ) -> MessageProcessor.{messages} {
        std::mem::drop(self.statistics);
        self
    }
}
```
  That'd be neat.