We Love Privacy Club

feeds.twtxt.net

D7VK 2.0 released with more performance fixes for retro Direct3D games on Linux
Love your classic retro games? D7VK 2.0 is out now to bring more performance improvements for running retro Direct3D games on Linux.

Image

Read the full article on [GamingOnLinux](https://www.gamingonlinux.com/2026/07/d7vk-2-0-released-with-more-performance-fixes-for-retro-direct3d-ga … ⌘ Read more

⤋ Read More

gaming-on-linux

feeds.twtxt.net

Sun, Jul 19 1:00AM (9w ago)

DXVK 3.0.2 brings bug fixes for Dying Light: The Beast, Halo and more on Linux / SteamOS
Direct 3D 8, 9, 10 and 11 to Vulkan layer DXVK has a new bug fix release out, sorting some issues in specific games to make gaming on Linux / SteamOS better.

Image

Read the full article on [GamingOnLinux](https://www.gamingonlinux.com/2026/07/dxvk-3-0-2-brings-bug-fixes-for-dying-light-the … ⌘ Read more

⤋ Read More

movq

www.uninformativ.de

Thu, Jul 16 12:00AM (9w ago)

I really think I should go back to Java.

Writing programs in Python is so exhausting. I want a compiler and I want static typing. No, linters and type checkers and IDEs are not good enough. Compilers catch way more errors in advance.

Rust is also exhausting. They’re constantly adding language features and, at the same time, the runtime library remains tiny and you need 3rd party libraries for everything. Many of those are still at version 0.x (SemVer!) and you can’t rely on anything. Often times, you need the latest Rust nightly compiler.

Go is … I don’t like it. And huge binaries.

I like C as a language, but it’s too fragile. I want to have a proper HashMap every now and then.

None of the above have good GUI libraries, at least not on Linux.

And then there’s Java. This is my fractal renderer that I wrote over 17 years ago:

https://movq.de/v/fcd3c4e557/vid-1784121825.mp4

It’s fast. It has a GUI with custom widgets and those weren’t even hard to make. It still works without changing a single line of code. The source code files have timestamps from 2009 and I just noticed that the JAR file I’m using in the video was compiled in 2010.

Java as a language is relatively easy to learn and to master. There are few surprises. The source code organization with packages is good. Java API docs are clear and well written.

The JVM ramp-up times have improved considerably:

https://movq.de/v/e7314e521e/vid-1784121998.mp4

This isn’t like the Dark Ages anymore. Might even be usable for some CLI tools.

The only thing where Java really sucks is anything close-ish to the kernel. Try issuing an ioctl() … I couldn’t have made my TUI framework in Java, but then again, I wouldn’t have needed to because Swing already exists and it just works.

⤋ Read More

prologic

twtxt.net

Tue, Jul 14 9:16AM (10w ago)

↳ In-reply-to » The original twt is unavailable. It may have been edited or deleted, or is from an unknown or muted feed.

@balloon-fu-sen@tw.fus.f5.si Thank you for reaching out 👌 I had alraedy done so via Email too a few days back and she upgraded her Pod to yarnd/0.16.x 🎉

⤋ Read More

prologic

twtxt.net

Tue, Jul 14 7:55AM (10w ago)

Linux 0.11 rewritten in idiomatic Rust, boots in QEMU | Hacker News Fark’n hell, this is some ~50k SLOC of Rust code compared to the original ~8k SLOC of C of the original this was based off of. No doubt this was “vibe coded” for sure, there is no way a human can write 50k SLOC, not in a reasonable timeframe anyway 😅

⤋ Read More

lyse

lyse.isobeef.org

Tue, Jul 14 7:00AM (10w ago)

Hurray, I can now press gg instead of g to go to the top in tt. Much better! :-) Other multi-key combinations are also easily possible now.

I should probably write a real article about this at some point, but here we go. The only downside with my new key binding system is that it breaks tview’s established pattern. You’ve got an InputHandler(), that is implemented using WrapInputHandler(…). It typically then directly implements the switching logic depending on the key press. Something like this:

func (w *Widget) InputHandler() func(event *tcell.EventKey, setFocus func(p tview.Primitive)) {
    // WrapInputHandler allows for intercepting key events with SetInputCapture(…)
    // from the outside for customization. This handles the default key bindings.
    return t.WrapInputHandler(func(event *tcell.EventKey, setFocus func(p tview.Primitive)) {
        switch event.Key() {
        case tcell.KeyRune:
            if event.Modifiers() == tcell.ModNone {
                switch event.Rune() {
                case 'k':
                    w.scrollUp()
                    return // we already handled the event, stop processing

                case 'j':
                    w.scrollDown()
                    return
                }
            }
        }

        // We didn't handle the key event. Maybe the parent
        // widget knows what to do with it.
        if handler := w.parent.InputHandler(); handler != nil {
            handler(event, setFocus)
        }
    })
}

From the outside, you can intercept and either stop or continue the widget’s original key handling with a potentially rewritten key event using SetInputCapture(…):

w := NewWidget()
// customized or additional key bindings
w.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {
    switch event.Key() {
    case tcell.KeyUp:
        // Rewrite the event, so the "cursor up" key is an alias
        // for the vim key binding "k", that is handled by the
        // wrapped input handler above. (I know, I know, this is a
        // completely unrealistic example, why would anyone use
        // cursor keys when there are vim key bindings available?!)
        return tcell.NewEventKey(tcell.KeyRune, 'k', tcell.ModNone)

    case tcell.KeyRune:
        if event.Modifiers() == tcell.ModNone {
            switch event.Rune() {
                case 'q':
                    app.Stop()
                    // we already handled the event, do not pass it
                    // to the wrapped input handler above
                    return nil

                case 'r':
                    toggleMessageReadStatus()
                    return nil
            }
        }
    }

    // we didn't handle the event, pass it to the wrapped
    // input handler above
    return event
}

Since they all expect a single key, I’ve noticed that using multiple dedicated KeyBindings of mine on these different levels kinda breaks multi-key handling with common prefixes. The outer-most KeyBinding captures the prefix, but it can’t transfer it to the inner one if not handled by the outer one. At least not without some more (potentially ugly) changes. So, I now have to work with just a single KeyBindings object for the entire widget chain (if it consists of multiple other widgets or the regular input handler and input capture are in the game). The outside needs to register all its key bind customizations or extensions at the same level that the original widget handles its default ones. Doable by exposing the widget’s KeyBindings instance, but not pretty. You always have to keep this in mind.

With the KeyBindings, it will look like that:

type Widget struct {
    parent tview.Primitive

    // make it available to children or the outside either by
    // direct field access or by providing a getter method
    KeyBindings *bind.KeyBindings
}

func NewWidget() *Widget {
    w := &Widget{KeyBindings: &bind.KeyBindings{}}
    w.KeyBindings. // default key bindings
        Bind0(bind.KeySequence('k', w.scrollUp).
        Bind0(bind.KeySequence('j', w.scrollDown)
    return w
}

func (w *Widget) InputHandler() InputHandler() func(event *tcell.EventKey, setFocus func(p tview.Primitive)) {
    return t.WrapInputHandler(func(event *tcell.EventKey, setFocus func(p tview.Primitive)) {
        // also note the missing support for focus transfer at the moment
        event = w.KeyBindings.Capture(event)
        if event == nil {
            return
        }

        if handler := w.parent.InputHandler(); handler != nil {
            handler(event, setFocus)
        }
    }
}

And then from the outside, or in a child widget:

w := NewWidget()
w.KeyBindings. // additional or customized key bindings
    Bind1(bind.KeySequence(tcell.KeyUp), func(*tcell.EventKey) *tcell.EventKey {
        return tcell.NewEventKey(tcell.KeyRune, 'k', tcell.ModNone)
    }).
    Bind0(bind.KeySequence('q'), app.Stop).
    Bind0(bind.KeySequence('r'), toggleMessageReadStatus)

When directly working with tview primitives that are not part of custom widget implementations, the following works well so far:

textView := tview.NewTextView().
    SetWordWrap(true).
    SetText("…")
    SetScrollable(true)
textView.SetInputCapture((&bind.KeyBindings{}).
    Bind0(bind.KeySequence('q'), app.Stop).
    Bind1(bind.KeySequence('g', 'g'), func(*tcell.EventKey) *tcell.EventKey {
        return tcell.NewEventKey(tcell.KeyHome, 0, tcell.ModNone)
    }).
    Capture)

I need to sleep on this some more.

Also, writing very long messages like this one is really not all that fun in tt’s editor. I should absolutely provide a way to shell out to vim.

(Took me about one and a half hours to compose, holy crap. But not only because of not using vim. Although, that might have saved me a quarter hour or so for sure. Proof-reading this message also uncovered quite a few bugs in my real documentation. So, that’s a big win!) Good night!

⤋ Read More

prologic

twtxt.net

Sun, Jul 12 12:09PM (10w ago)

🥳 Finally! After nearly 4 years, yarnd v0.16.0 “Silver Sojourner” is out! 🚀 Twt Hash v2, SQLite FTS5 search, HTMX-powered UI, first-time setup wizard and literally hundreds of bug fixes 🐛

Release notes: https://git.mills.io/yarnsocial/yarn/releases/tag/0.16.0

Upgrading is fully automatic — the Twt Hash v2 migration re-fetches all feeds on first start, so expect the first cycle to be a bit heavier. Images on Docker Hub as prologic/yarnd:0.16.0 👌

cc @kat@yarn.girlonthemoon.xyz @abucci@anthony.buc.ci @shinyoukai@yume.laidback.moe @eldersnake@we.loveprivacy.club 🙏

⤋ Read More

movq

www.uninformativ.de

Fri, Jul 10 11:19PM (10w ago)

↳ In-reply-to » I’m in the process of making a big page with photos and screenshots, and this is more stuff than I expected. 🫩

There you go: https://movq.de/blog/postings/2026-07-10/0/POSTING-en.html

⤋ Read More

movq

www.uninformativ.de

Tue, Jul 7 4:17AM (11w ago)

↳ In-reply-to » The original twt is unavailable. It may have been edited or deleted, or is from an unknown or muted feed.

@GabesArcade@gabesarcade.com The no-JS part is one thing, but you also have to disable the (nowadays common) forced-HTTP-to-HTTPS-redirect, because those old browsers can’t do modern crypto. And make sure that your webserver serves the correct page even if no Host header is sent by the client. And don’t even think about serving UTF-8 or even just putting utf-8 in the content type. 😅 And for the JPEG thumbnails I pass a special flag to ImageMagick so that IBM Web Explorer from OS/2 won’t trip. 🤣 And always use link rel="stylesheet" for CSS, because some browsers render inlined CSS as literal text. And … probably more that I forgot by now. 😂

@david@daiwei.me Not sure, actually. Let’s see. Those are the ones where I still have the original disks (or have bought them on eBay again):

SuSE Linux 6.4 (it’s a massive 7 CD distro with a huge manual, best thing ever)
OS/2 2.1
OS/2 Warp 3 (red and blue spine because $reasons)
OS/2 Warp 4
PC DOS 7
MS-DOS 6.22
Windows 3.1
Windows for Workgroups 3.11
Windows 95 C
Windows 98
Windows NT 4 Workstation (still in the mail, though 😅)
Windows 2000
Windows XP Professional (last Windows I ever used on my private PCs)

(Plus a few “classic” office products as can be seen here: https://movq.de/blog/postings/2024-05-23/0/POSTING-en.html )

⤋ Read More

lyse

lyse.isobeef.org

Sun, Jul 5 4:00AM (11w ago)

↳ In-reply-to » The mentioned go.{mod,sum} change is already part of tview 0.42.0. After implementing Set/GetDisabled(…) and PasteHandler(), tt starts up fine and seems to work without issues.

After updating to tview 0.42.0, I also sadly noticed, that the tview.Modal now clears the background and doesn’t simply draw over the already present widget. So, I decided to write my own Dialog widget. This endeavor lead me down the path to actually bring back a custom Button implementation, too. When the button is focused, it surrounds the button text with [ and ]. When not in focus, the brackets are removed. Much better than before (https://twtxt.net/conv/qx3vz4a):

I also use the same buttons in the compose view, too.

⤋ Read More

Yarns

search.twtxt.net

Sat, Jul 4 3:12PM (11w ago)

🥳 NEW FEED: @dce@hashnix.club

⤋ Read More

lyse

lyse.isobeef.org

Sat, Jul 4 2:45AM (11w ago)

@movq@www.uninformativ.de https://movq.de/blog/postings/2026-07-03/0/POSTING-en.html Oh yeah, the toolbar handles. You could actually move the toolbars around and sometimes even customize them. I have no evidence, but to me it feels like a lot of programs don’t allow that anymore nowadays.

⤋ Read More

Searching We Love Privacy Club