The Rex for Windows alpha begins today! I think this is a better terminal than Windows Terminal, and I think WT is pretty good. Nick did an amazing job here, I think you’re about to feel one of the snappiest, most beautifully rendered Windows apps ever.
This is all Nicks amazing work but some cool tech details: this is written in Odin! And it’s built on a completely custom GUI framework that leverages native widgets where possible but does plenty of fully custom drawing. The renderer is completely custom and built on DirectX, highly optimized to draw the full UI in one pass and supports things like animation and cursor shaders.
Overall its one hell of a piece of software and I can’t wait for people to feel it.
A thousand years ago, I made a dent in dev envs with “Vagrant.” The most popular request always was “I want Vagrant for remote envs.” I’ve been asked this to this day!! I tried and failed many times. I made things that worked but didn’t work right. Well, Rex is done right. Rex is my answer, finally.
It’s always lived in the back of my mind no matter what I did. I would come up with something and try it and it didn’t feel right.
I got really close around 5 years ago to the point I setup a website branding etc (via HashiCorp). But at the last minute I pulled it. It still wasn’t right. I couldn’t explain why and didn’t have a better solution. I just knew it had to be binned.
Well, Rex is it. This is the real deal.
Rex is doing for remote development (and a lot more than just dev) what I think a proper solution should’ve done. It’s far more than just a dev tool but I think part of what I knew is once you reach into remote environments that line isn’t clear anymore. You have to solve both remote dev and remote prod.
Here we go, back to the beginning.
Rex demo time: magical and automatic remote copy/paste, drag/drop, and port forwarding (e.g. open web servers running on remote machines in your local browser). Plus, showcasing some of the internal plumbing that powers this and how you can hook into it with Lua scripting.
Our goal with Superlogical and Rex is for everything to feel local. I've said before: the moment any UI shows a selector between "local" and "cloud", the product has failed. The lines should blur, and we should build the foundational technology that makes it happen performantly, securely, and beautifully.
Appreciate it! I think I speak for everyone at Superlogical that we’re tired of software that feels like demoslop and we’re motivated to show the world what meticulously crafted software feels like again.
We use AI of course, but showing the difference between tasteless prompting and a team of experienced craftspeople enhanced by AI. We hope!
libghostty-vt 1.0.1 released. ABI stable so its a drop-in upgrade. Biggest highlight is that we provide prebuilt Windows builds now (DLL and static libs)! Also just a good group of performance improvements and bug fixes. Enjoy the hand-written release notes below.
Windows builds here: lib.ghostty.org/vt/installin… ("Windows")
Highlights
- Prebuilt Windows builds. Releases now include zips for x86_64 and aarch64 (Windows on Arm), each with the DLL, import and static libraries, headers, CMake and pkg-config files.
- Faster memory operations on Linux. Builds that dynamically link glibc now use its memset, memcpy and memmove, which pick the best CPU features at runtime and beat Zig's compiler_rt in every benchmark we have.
- Fixed garbled input with an AVX-512 system.
Bug Fixes
- Resizing the column count no longer leaves stale shell prompts behind when the shell redraws its prompt (OSC 133). This was most visible with full-line prompts like powerlevel10k.
- A resize that grows rows and shrinks columns at the same time now pulls scrollback down correctly, matching what you get from doing the two resizes one after the other.
- A failed render state update no longer marks unfinished rows as clean. Those rows stay dirty and are rebuilt on the next update, instead of being rendered from incomplete data (which could crash).
- Kitty graphics: during a chunked transmission that replaces an image, the old image now stays until the transmission ends, instead of disappearing on the first chunk.
Performance
- Setting a scrollback line limit now performs the same as a byte limit. We previously decommitted memory only in the line-limit case, which caused storms of page faults. With a 1,000-line limit, ASCII throughput went from 298 to 1,983 MB/s on Linux (6.7x) and from 2,214 to 4,093 MB/s on macOS (1.8x). Matches byte limit performance.
- A restored snapshot's last page now gets its full pooled capacity, so the first write after a restore doesn't immediately allocate.
- Linux builds that dynamically link glibc now use glibc's memset, memcpy and memmove (with runtime CPU feature detection) instead of Zig compiler_rt's. ASCII with no scrollback is 23% faster on arm64 and 10% faster on x86_64. Resizing is 4–10% faster.
- UTF-8 decoding after the first invalid sequence no longer decodes valid runs twice. Valid input is unchanged, and input with invalid sequences decodes 6–10% faster.
- Faster CSI parameter parsing: 14 instructions and 2 branches per digit on x86-64, down from 23 and 5. Style-heavy streams are up to 5% faster.
- Less per-segment overhead in RenderState.endUpdate.
- Validating C enums no longer scans every field.
Packaging
- Releases now include prebuilt Windows zips for x86_64 and aarch64 (*-windows-gnu).
- On Windows, pkg-config files are relocatable and aarch64-windows-gnu builds.
- Statically linked Darwin builds no longer pick up our memset over libSystem's.
We're still so small but I'm loving the team we've got at Superlogical. They're so talented and kind and love their craft. It's a different era of software development and our expectations and practices reflect that. I want to share a bit about how we work.
First, everyone is trusted to push to main. We do machine-aided code review pre-push and human plus more machine-aided code review post-push. Limited to no PRs.
Culturally, we've all agreed that if we ever hire someone who we DON'T trust to push directly to main, then they probably aren't the right fit for the team (so far, not an issue).
Some common sense here: if someone is stepping outside their lane or comfort zone, we'll open PRs. For example, I'm pretty trash at macOS/iOS UI, so I'll open PRs for UI-affecting functionality and ask for eyeballs/help. But for business logic and internals, I push to main.
Second, everyone can cut a release. Our release process is fully automated and when you start a release (for any platform) it triggers a Slack notification and a 15 minute countdown.
The 15 minute warning is a final gate that allows people to review plus collaborate on a changelog. During that 15 minutes, anyone in the company can pause the release rollout. After 15 minutes, the train leaves the station. You can't override the 15 minutes (except to pause). It gives everyone a chance to step in.
Third, we avoid synchronization through fast remediation rather than through planning. The server and clients on various platforms ship features as fast as they can. We use post-hoc human review and AI-assistance to identify feature mismatches across products ("Windows has support for X and Mac doesn't." or "Mac and Windows differ in their behaviors for Y in this way.").
This avoids expensive "sync" meetings and coordination. We trust that producers of features are mindful of what they're producing and we trust that adjacent product lines will self-synchronize quickly. In practice, we see feature parity across platforms within 24 to 48 hours.
All of this works on mutual trust. It ONLY works with mutual trust.
Everyone at all times has to trust that they've got each others back:
1. Push to main only works if you fix your mess, or if you don't, that someone else will quickly but that you'd do the same (and generally in equal amounts).
2. Anyone can deploy only works if you trust everyone to cut at the right time, with the right changelog, and that people will respect the 15 minute timer.
3. Sync through fast remediation only works if you trust other teams will pick up and integrate your work quickly, which only works if you would too. It also only works if you are fairly producing mismatches (e.g. not constantly).
We've got a great team. I know we're still small and that these practices will change in many ways as we scale. But this is already a markedly different practice than what I would've done 15 years ago.
In general, we are building from day 1 on a foundation of mutual respect, excellence, and trust. And it's been awesome.
This is a good filter for people who I don’t want to work with. Please understand how computers work. This isn’t even about understanding Docker. Any software person should know how the layers work at a high level and this is a VERYYYYY high level.
libghostty 1.0 is here! I started Ghostty ~5yrs ago to work towards this. Today, libghostty is in hundreds of projects used by tens of millions of people. 1.0 marks ABI stability, quality, and an invite for distros to begin packaging. mitchellh.com/writing/libgho…
Since starting the Ghostty project in 2022, the most common question I've been asked is "why?". Today, I'll answer this by showing the broad industry impact libghostty has already had.
On top of JetBrains and Neovim already mentioned (that alone being over 10 million users):
-KDE developers are experimenting with a Konsole replacement built on it.
- Vercel's Turborepo uses it to render task output in its TUI.
- devenv uses it to drive shells.
- Antithesis used it to fuzz TUI programs and found real bugs in btop and others.
-Ghostel brings it to Emacs.
- ghostty-web is the WASM build with an Xterm.js-compatible API.
- Commercial products like OrbStack embed it.
- And a whole wave of new terminals and "agentic" coding tools, such as herdr and cmux, have been built on it rather than writing yet another emulator.
There are community bindings for Rust, Go, JavaScript, Swift, Python, .NET, Elixir, Dart, Java, and more, and the awesome-libghostty list tracks well over a hundred projects.
More people today use a terminal powered by libghostty than use Ghostty the application, by a very large multiple. And libghostty is having a much larger impact than being "just" a terminal emulator.
I'm excited to see where people take it from here.
Surprise! We have a gorgeous, high quality windows client. We’ve been waiting to share until we have a relatively complete (but still pre alpha) client here, but we’re getting ready to start external testing. Hello, Windows.
our goal for Rex clients from the start was to build the most magical terminal app and to make it feel native on every platform. to me that doesn’t mean porting the same UI around. it means embracing the norms and quirks of each platform, so the app feels at home on your system rather than a guest that calls attention to itself.
we’re about two weeks away from inviting the first wave of alpha users to Rex for Windows. it’s a fully reimagined version of our Mac app that still keeps the feel that makes the Mac app special. it’s crazy fast, the UI is entirely gpu-driven, and just like on Mac, it works as both server and client.
here's a little video of me demonstrating some of the basics. I'll stress that this is pre-alpha right now, there is a lot to polish and port still, but I'm very excited about putting this in the hands of users soon.
Today we’re announcing that OpenAI will acquire @pierrecomputer to accelerate our vision for making Codex a place where teams can build software together with AI, from first idea to the version they ship.
Pierre’s open-source developer tools already power parts of Codex today. Together, we’ll build on that foundation for the agentic era.
openai.com/index/openai-to-a…
Everyone is an expert on mach tuck and the aerodynamic effects of icing now I guess. Their stated qualifications are that they've been Delta Platinum Medallion for 8 years and got to shake hands with the pilot one time. Alright.
As a pilot*, I find it really fucking annoying that every non-qualified Dunning-Krugered armchair critic comes out for every aviation accident to provide their uneducated and often embarrassingly wrong takes on aviation in general. Even I refrain, and I'm more qualified than many!
*: I'm a baby pilot. I flew for ~10 years, acquired around 2,000 hours. 1,000 of my hours were in a jet. I've flown to nearly every state in every season.
Despite all that, I'm still wildly unqualified to make any sort of conclusions about most topics on here. So I don't.
And yet, there are many who are simply passengers with zero hours logged whatsoever (or, non-A&P or even ground crew!) making grand claims about how aviation works, what regulatory bodies should/shouldn't do, pilot qualification judgements, etc.
Gross.
A quick note. On both Linux and macOS, libghostty already processes data faster than the kernel can supply it over a pty fd. Ghostty is literally the floor of how fast `cat` can get (over plain text). So the plain ASCII/Unicode improvements here do NOT translate to visible `cat` speed differences.
The speedups aren't for nothing though: they are visible in real-world mixed-data throughput because some sequences still can't be processed faster than a kernel read, so if libghostty is e.g. stalled handling some slow OSC, we'll catch back up much faster when we hit plain text runs.
Also, for non-pty reads such as direct files or direct from memory, e.g. on stored or generated output, libghostty can process this data according to the speed increases shown below.
I've enjoyed the `cat` benchmark for a long time, but I am sad to say its done. We've finished it. It can't get any faster without kernel changes.
libghostty has always been fast, but it's also been getting significantly faster. Here are IO throughput measurements comparing Ghostty 1.3.1, 1.4.0, and main as of this morning. We'll be backporting most of these to a 1.4.1 release soon.
Here are some highlights of the changes since 1.4:
- Ghostty 1.4 had a fast-path for printing runs of plain text. But the fast-path only applied to limited cases. We now support mixed width characters and hyperlinks in the fast path.
- Our input path always widened the pty data to codepoints (8-bit to 32-bit) as part of UTF-8 decode, which also incurred a memory copy. We now have a SIMD fast path to detect pure-ASCII and we process the run direct from the read buffer (no copy, narrower data).
- New memory pages use most recent two pages actual utilization to pre-size themselves accordingly. This sped up styles, hyperlinks etc.
- When a VM page runs out of capacity for a certain type of data (e.g. hyperlinks, styles), we now project the usage so far to guess what you'll need, then shrink available rows to avoid a realloc. Before we'd naively double. This caused a classic "laddering" problem.
- We recognized "erase" being a slow path for us, and it's a common sequence, so we use another bit in row headers to track blank (we had space).
- Styles are now processed once per SGR. Previously, a sequence like "ESC[1;38;2;r;g;bm" would apply each style as it came in (1, then 38, then 2, etc.). We now apply all attributes at once and write to the cursor atomically.
- Styles are now packed into 128-bit values and use aarch64 and x86_64-specific assembly for minimizing instructions to use it.
- On x86_64, we found that LLVM was lowering some row resets (hot path) to a 4-byte store followed by an 8-byte load which couldn't be store-forwarded. This caused an almost 10% (!!!) slowdown on scroll operations only on x86_64. The fix was to change our reset to build the full header in a register then do a single memmove per row.
Net results are what you see in the graph, but written out main to 1.4: ASCII 1.5x, heavy styling 1.5x, styled Unicode 1.8x, random UTF-8 1.4x, random OSC 8 2.7x, mixed styled text with links 4.8x, cursor/erase 16x, hyperlink-dense text 5.6x.
libghostty has always been fast, but it's also been getting significantly faster. Here are IO throughput measurements comparing Ghostty 1.3.1, 1.4.0, and main as of this morning. We'll be backporting most of these to a 1.4.1 release soon.
Here are some highlights of the changes since 1.4:
- Ghostty 1.4 had a fast-path for printing runs of plain text. But the fast-path only applied to limited cases. We now support mixed width characters and hyperlinks in the fast path.
- Our input path always widened the pty data to codepoints (8-bit to 32-bit) as part of UTF-8 decode, which also incurred a memory copy. We now have a SIMD fast path to detect pure-ASCII and we process the run direct from the read buffer (no copy, narrower data).
- New memory pages use most recent two pages actual utilization to pre-size themselves accordingly. This sped up styles, hyperlinks etc.
- When a VM page runs out of capacity for a certain type of data (e.g. hyperlinks, styles), we now project the usage so far to guess what you'll need, then shrink available rows to avoid a realloc. Before we'd naively double. This caused a classic "laddering" problem.
- We recognized "erase" being a slow path for us, and it's a common sequence, so we use another bit in row headers to track blank (we had space).
- Styles are now processed once per SGR. Previously, a sequence like "ESC[1;38;2;r;g;bm" would apply each style as it came in (1, then 38, then 2, etc.). We now apply all attributes at once and write to the cursor atomically.
- Styles are now packed into 128-bit values and use aarch64 and x86_64-specific assembly for minimizing instructions to use it.
- On x86_64, we found that LLVM was lowering some row resets (hot path) to a 4-byte store followed by an 8-byte load which couldn't be store-forwarded. This caused an almost 10% (!!!) slowdown on scroll operations only on x86_64. The fix was to change our reset to build the full header in a register then do a single memmove per row.
Net results are what you see in the graph, but written out main to 1.4: ASCII 1.5x, heavy styling 1.5x, styled Unicode 1.8x, random UTF-8 1.4x, random OSC 8 2.7x, mixed styled text with links 4.8x, cursor/erase 16x, hyperlink-dense text 5.6x.
A quick demo of floating panes in Rex, some of their features, and how I use them in my daily workflow. I think our implementation of floating panes looks great and feels great and I think you'll love it! These are also all scriptable and API driven, too, of course!