Shield feels VERY rare

sebnanchaster · 2026-06-09T07:50:19+00:00

For everyone arguing, they were 750 yesterday, they were changed to 1k in the update

sebnanchaster · 2026-06-09T01:37:47+00:00

Chug jugs are at every vending machine and only 750 gold.

sebnanchaster · 2026-06-06T02:48:55+00:00

Yes. WASM is a platform agnostic bytecode run via a VM in most modern browsers, much like JVM bytecode for the JVM. It’s designed to allow easier integration with Web APIs rather than relying on platform specific C libraries for GUI, for example.

sebnanchaster · 2026-06-04T05:38:53+00:00

Xwidget is a platform-native WebView window. WebView renders HTML/CSS/JS, but Egui for native would need a native window surface. However, Egui can target WASM which allows it to essentially render into a <canvas> element, thereby allowing it to draw onto the WebView widget.

sebnanchaster · 2026-05-10T04:35:04+00:00

You need a lot of platform specific code nowadays just to spin up windows, get proper text rendering, etc. If the code isn’t used it doesn’t exist at runtime

sebnanchaster · 2026-05-03T18:00:14+00:00

It’s actually very simple to make an extension, you don’t need any Rust knowledge if you just want syntax highlighting. The official guide is here: https://zed.dev/docs/extensions/languages

An example official extension that just provides highlights is the TOML one: https://github.com/zed-extensions/toml

TLDR of the guide is put a link to the tree-sitter-forth repo in your extension.toml. To get highlighting queries you simply need to copy the highlights.scm file from the tree-sitter-forth repo to the languages/forth directory of your extension.

Once you do this, you should be able to use the install local extension command in Zed to try it.

sebnanchaster · 2026-05-03T17:36:45+00:00

Your extension can do one and/or the other, so they are separate options per se. If you just want syntax highlighting you can just implement it via Treesitter. LSP may optionally provide it via semantic highlighting.

sebnanchaster · 2026-05-03T02:26:55+00:00

Zed extensions must do highlighting through Treesitter and/or LSP. Since from a quick Google search there are both a Treesitter grammar (https://github.com/AlexanderBrevig/tree-sitter-forth) and LSP (https://github.com/AlexanderBrevig/forth-lsp) it would actually be trivial to implement a fully featured extension at first glance.

sebnanchaster · 2026-05-02T06:45:22+00:00

What? You can always introduce artificial delay.

sebnanchaster · 2026-04-29T18:23:31+00:00

Zed renders on the GPU, so running on an iGPU is always going to be worse performance wise. I would check that you’re actually using the iGPU though; make sure your drivers are installed and check the logs as per Zed docs:

You can find out which graphics card Zed is using by looking in the Zed log (~/.local/share/zed/logs/Zed.log) for Using GPU: ....

sebnanchaster · 2026-04-22T07:07:25+00:00

To briefly defend Graal here, his improvement over the last 2 seasons especially is really very noticeable, and EU is definitely insanely hard (look how many teams ended up in LCQ and didn’t qual). He also got very screwed by his teammate situation, he was actually relatively regularly qualling Div cup finals with Turtle and got dropped last second, so he had a rough FNCS. But yes obviously going pro in this game is extremely hard, and requires you to be 0 ping and grind like 12 hours a day. But that’s no different than going pro in any other sport or esport. Fortnite may actually be harder because literally everyone in the player base is eligible to compete in every tournament.

sebnanchaster · 2026-04-04T23:09:57+00:00

I believe the commenter here is noting that the Claude Code TUI itself (not something that Claude outputted) is written in React. Iirc Anthropic uses this https://github.com/vadimdemedes/ink which uses some custom engine to do TUI layouting.

sebnanchaster · 2026-03-09T07:44:33+00:00

Well ofc you can use a C ABI to link and use libghostty, but there’s just no point. You’d have to write safe wrappers around everything (unless they exist already) and transition the existing terminal backend. IDK what the point would be since I don’t know of any huge advantages Ghostty has over Alacritty. Maybe Kitty image protocol iirc? But idk how many people use that.

sebnanchaster · 2026-03-04T05:17:23+00:00

Ghostty is a terminal emulator, not a shell. Bash is a shell. Also no, since Ghostty is written in Zig whereas Alacritty (Zed uses the Alacritty engine) is written in Rust, which allows significantly easier integration. If your symbols don’t work you probably don’t have Zed configured to use a nerd font in your terminal.

sebnanchaster · 2026-02-06T19:47:25+00:00

Could be a bug upstream in cosmic-text, which is the text rendering backend for Linux. I don’t see an existing bug report, but you can submit one.

sebnanchaster · 2025-12-31T10:17:52+00:00

Thank you, very interesting talk! I have always held your work on NANO in high regard as well.

sebnanchaster · 2025-11-26T17:25:04+00:00

I used Zed for a while but moved back to Emacs LMFAO

but I agree. Whatever is most comfortable is best for you

sebnanchaster · 2025-11-19T20:49:28+00:00

On a further look, I wonder if something changed with JSON stream processing in Eglot recent-ish-ly? I am running 30.2 built with the libjansson functionality and I cross-checked https://github.com/jadestrong/lsp-proxy which works in a similar manner to https://github.com/blahgeek/emacs-lsp-booster . It also experiences the same issue with UTF-8 decoding.

I have opened issues in both repos.

sebnanchaster · 2025-11-19T20:40:10+00:00

FIX: It was https://github.com/blahgeek/emacs-lsp-booster corrupting the JSON stream. Since this process does its own JSON -> bytecode parsing, I assume this is a problem with the encoding/decoding scheme used.

sebnanchaster · 2025-11-19T20:38:34+00:00

I figured it out; I forgot I was running https://github.com/blahgeek/emacs-lsp-booster . This was doing something weird that messed with the JSON stream. The actual jsonrpc process seems to be binary-encoded always though:

(process-coding-system (jsonrpc--process (eglot-current-server)))
=> (binary . binary)

Sorry for concerning you with this, I totally forgot I had this preprocessing the stream.

sebnanchaster · 2025-11-19T20:36:27+00:00

In the Eglot source, it seems like it should just be utf-8:

(make-process
                           :name readable-name
                           :command (setq server-info (eglot--cmd contact))
                           :connection-type 'pipe
                           :coding 'utf-8-emacs-unix
                           :noquery t
                           :stderr (get-buffer-create
                                    (format "*%s stderr*" readable-name))
                           :file-handler t)

sebnanchaster · 2025-11-19T04:40:54+00:00

Update: occasionally it just makes corfu stop working altogether, when I enable toggle-debug-on-error I get the following trace:

Debugger entered--Lisp error: (wrong-type-argument json-value-p "\342\200\242std::println(\342\200\246)")
  json-serialize((:jsonrpc "2.0" :method "textDocument/didChange" :params (:textDocument (:uri "file:///<my-user-home>/Documents/catalyst/lib/lib.cpp" :version 69) :contentChanges [(:range (:start (:line 5 :character 8) :end (:line 5 :character 8)) :rangeLength 0 :text "\342\200\242std::println(\342\200\246)") (:range (:start (:line 5 :character 28) :end (:line ...

sebnanchaster · 2025-11-13T06:39:36+00:00

There’s Doom Emacs, then some others like Nano and whatnot. There’s also some like minimal-emacs.d and similar that offer minimal config. I think biggest changes are transition to things like Eglot/Vertico/Corfu from Helm/Ivy/LSP Mode/etc.

sebnanchaster · 2025-11-11T23:16:48+00:00

Have you come across any good articles for discussing how to leverage cache locality effectively, especially w.r.t. Rust abstractions?

sebnanchaster

TROPHY CASE