For a brief moment I thought this is about the game Rune[1] and got excited as I have played that a lot when growing up. Alas, that wasn’t it.

[1] https://en.wikipedia.org/wiki/Rune_(video_game)

• sheepscreek

  yesterday at 11:58 PM

  I must have the attention span of an ant. This happened to me TWICE today.

• nailer

  yesterday at 10:05 PM

  The game has a cool moment where the hero defeats Loki's minion by pushing him into some water. Loki then spells his blood in the water, reviving and corrupting the minion.

  You beat the minion, but to leave the area, you need to bathe in the same blood, and become corrupt like the monsters. You then return to your village, giant and powerful but no longer a person.

  https://youtu.be/s-j5n-Sw10M

I like the idea of making it trivial to work across multiple machines but I’d really prefer not to have to trust your coordination server and encryption approach etc.

Could this (optionally) just run over Tailscale (I suppose ssh is always an option)

https://docs.rune.build/learn/network

• ernestrc

  yesterday at 7:19 PM

  Yes, SSH is always an option, but it could totally work with a Tailscale network. In fact, we embed tsnet in Rune and use headscale as the coordination server, so there's nothing special about Rune's network. In the future, we're planning on adding more clients (iOS, Android), so hopefully it'll be more compelling then.

Exciting to have a hackable Go based editor. The onboarding was pretty nice from a Vim user. Although I'm having some trouble with my fish shell also having vim bindings.

> we will give participating contributors a contractual right to share in the revenue generated by Rune, directly or indirectly.

this sounds like a terrible idea. the only incentive to contribute to your project should be to fix a bug or contribute a feature upstream you yourself need.

consider the fallout of Hacktoberfest, 'Tide' or the ai produced PR spam for social clout on GitHub as of today and then imagine what happens if someone provides a direct financial incentive to do it.

Author here! The post explains some of the details behind using Go as the primary language for building an IDE. It also introduces our novel contributor program, which will distribute some of Unstable Build's proceeds amongst participating developers, as opposed to making them sign a CLA to surrender their rights to a company. Happy to answer questions!

I am a huge advocate of this kind of app paradigm:

It’s now really easy to spin a terminal emulator and make cross platform terminal apps that work the same on Windows, macOS and Linux regardless of users terminal. You can also make sure the term sends everything required to make the app “nice”, like mouse hover events.

I started using this paradigm for some of my own company’s apps around 3 months ago because it was neat to allow the app to spawn DWM windows for sub windows, dialogs etc. but the app can also fall back to standard TTY for using over SSH or from within a docker or any other terminal. Also, using your own terminal window gives proper taskbar integration (stacking windows) and you can set your own app name/icon.

(It’s possible to 1-shot this in Python using the prompt “use ghostling as a reference, write a terminal emulator in Python using raylib and libghostty that hosts my app” and the first pass was around half the speed of Ghostty.)

The open ledger and profit-sharing for contributors might be an even more interesting innovation than the IDE itself. I like my existing IDE but Rune looks very nice so I'll certainly give it a whirl.

• ernestrc

  yesterday at 7:22 PM

  Thanks! We're still working on the legal details, but should have something finalized in the coming weeks.

You mentioned “it’s like driving a new car” in another thread; I tried Rune in an earlier incarnation, and it was more drastic than a new car. I’m a vim user, and so enabled the Vim option in onboarding - that was a big mistake, because I literally could not do anything without using vim motions. I felt like a helpless noob on my first unix, how-do-I-exit-this-dam-text-editor.

I realized that your onboarding was also training, and that I could not do anything with Rune without going through that training, and so I immediately exited and uninstalled. The friction was much too much.

I’m not sure if the onboarding is still like that :) If it is, my feedback would be have much much lower friction to try (or warnings for those who claim to use vim :).

• ernestrc

  yesterday at 9:17 PM

  I've gotten this feedback from other folks as well. I just can't seem to strike a balance between "what do I do now" and "this is too much training".

  > You mentioned “it’s like driving a new car” in another thread; I tried Rune in an earlier incarnation, and it was more drastic than a new car. I’m a vim user, and so enabled the Vim option in onboarding - that was a big mistake, because I literally could not do anything without using vim motions. I felt like a helpless noob on my first unix, how-do-I-exit-this-dam-text-editor.

  I'm almost tempted to take this as a compliment. I personally hated every other editor's "vim mode". I wanted Rune to be more than a regular editor with vim mode. fwiw you can turn-off vim mode in the terminal (and iirc, console and agent as well) and keep it in the editor.

  • threecheese

    today at 12:36 AM

    In one dimension, I'd also consider a compliment! "Purist" approach. However, given you are marketing Rune now, ... ... <--- insert unsolicited advice here lol

    Good luck, I mean it.

Lovely write-up! Will take a look at rune as an alternative to my Zed setup.

Not because I dislike Zed, I'm just addicted to trying out IDEs :)

• ernestrc

  yesterday at 6:30 PM

  Thanks! We spend so many hours staring at these UIs.. I totally get it. It’s like driving a new car.

I am already a zellij user and not sure if I want to drive everything from an IDE instead. I definitely see the appeal though.

I like the discoverability of the text prompt commands. I like that the terminal is more of a first class citizen. I like that I can run this with just `go run`.

The themes are pretty bad right now IMHO. I use solarized/gruvbox themes- both light and dark.

I'm going to give this a try because I once also tried to make a slick GUI ide with Vim key bindings. Unfortunately I was trying to use Rust then, of which I had no experience, while trying to write a desktop app, of which I also had no experience.

(I will try this as soon as there is a package in Fedora... That's my personal subjective bar to choosing a new EDITOR. But I definitely hope this succeeds, I'm a fan so far.)

• ernestrc

  yesterday at 6:26 PM

  It’s a long process to get into Fedora, but we’re gonna give it a shot for sure.

  • Conan_Kudo

    yesterday at 7:14 PM

    Since it's written in Go, you might want to reach out to the Fedora Go SIG and see if they can help you. :)

    • ernestrc

      yesterday at 7:52 PM

      :) https://forge.fedoraproject.org/go/sig/issues/1#issuecomment...

  • jmmv

    yesterday at 7:49 PM

    It is, but you can start with a COPR repo instead.

  • criticalfault

    yesterday at 6:42 PM

    what about flatpak?

    • ernestrc

      yesterday at 7:21 PM

      I've been using Arch Linux and macOS for the longest time, so I never saw the appeal with flatpak. It could be a good option until Rune is popular enough. fwiw I'm also working on a cask for homebrew.

I'm always looking for new gui code editors. For me right now Vscode is still the top (and since I've been trying Lean out it's required). Zed is a very close second.

One thing I would like to see on the home page is a video showing it being used. Also would like to see how it looks in a light theme. The repository says it's keyboard driven does that mean it's modal or can I still use it like a normal modeless editor?

• ernestrc

  yesterday at 7:14 PM

  > One thing I would like to see on the home page is a video showing it being used. Fair point. I've been meaning to record a video for a while, but I hate being in front of a camera.

  > Also would like to see how it looks in a light theme. Not great. I prefer dark themes so I haven't spent enough time making it look good on a light theme.

  > The repository says it's keyboard driven does that mean it's modal or can I still use it like a normal modeless editor? There's three modes, vim, emacs and standard, which determine the key bindings not just when opening a file, but also everywhere else. https://docs.rune.build/learn/standard-editor

  • bobajeff

    yesterday at 8:21 PM

    Thanks. A video of the editor itself is more what I'm thinking of. Something to show how it looks to work with it and explain what itch it's scratching etc.

vtebench is just what I've been wanting! Rune looks pretty cool too. Awesome to see people working on polishing things.

I've been building my own editor and gui toolkit, but modeled on Cocoa/OpenStep and similarly found tuning terminal performance involved more about tuning memory access and storage. That sounds somewhat similar to the experience in TFA.

Go is my the most favourite language, so I'm happy to see a Go based editor. However this days I'm writing code mainly in typescript (for Cloudflare workers). TS is the most popular language and you guys will definitely need to prioritize TS.

• ernestrc

  yesterday at 9:20 PM

  We're looking for someone to spearhead this effort: https://github.com/unstablebuild/rune/issues/50. I personally don't know enough about TS/JS's ecosystem to design a good experience. I know that Typescript's language server is one of the reference implementations, so at least the LSP part should be easy. What I'm not sure is what else is needed from a day to day workflow perspective.

  • icemanx

    yesterday at 10:21 PM

    you can safely ignore TS and focus on actual devs

    • effekt

      yesterday at 11:08 PM

      so, claude?

• adastra22

  yesterday at 8:15 PM

  Most popular in what field. Not every industry uses typescript.

Claude in a terminal is becoming more and more my IDE. I use emacs to do some edits or to look at some files, but orders of magnitude less than when I wrote all the code.

Syntax highlighting? Yes, for readability. Completion? I noticed today that maybe I broke the language server for Ruby but I didn't bother to investigate. Maybe next week, or next month.

Git log, blame, diff, yes, as usual.

I don't see a bright future for IDEs. Vi or emacs from the 90s could be all we need.

Non developers using AIs to vibe code their projects maybe won't need any editor at all, nor an IDE.

• natnatenathan

  yesterday at 7:39 PM

  I have found that I need more than this. A document viewer is critical so I can see HTML prototypes, review docs and other output and give feedback contextually inline (through a commenting system). I also need a task lists for my project/ agents so I can see where things are. I created an app like this for myself that is built around an integrated terminal, after I had the epiphany that VS Code (and VIM) were becoming the wrong tool because I am not actually spending time _writing_ the code.

  • ceehex

    yesterday at 8:47 PM

    all those things wouldnt be done in an ide anyways

    • natnatenathan

      yesterday at 10:48 PM

      fine, I need an "integrated agent collaboration environment" instead of an integrated development environment. I find value in them all being in the same app because it brings everything I need into a single work flow.

      • ragchronos

        yesterday at 10:56 PM

        Have you tried Zed?

        • natnatenathan

          today at 1:21 AM

          Kind of. I tried it on a really small project, but I've been reading about it and have seen a few demos and reviews. It is still too 'code focused' for me.

          For context, I am a product manager at a big tech company who has been building side apps for fun (and profit) since the days of Palm OS. I am effectively an SDE1 with 20 years experience, who has deep expertise in a lot of obsolete tech (C, Objective-C, Perl) and some exposure to modern stuff (TS, React, Rust, Swift).

          In the past year, I've been able to personally drive projects several orders of magnitude than what I could ever build myself. I'm not asking Fable to 1-shot grand theft auto, I am creating steering files, running adversarial reviews, prototyping, automating testing, and building my projects the slow way. Still, I don't write any code, just requirements and prompts and generate the rest. Our internal development teams at my company have arrived at a very similar process (much more sophisticated) by investing heavily in steering files that encode development approaches, harness and other mechanisms to automate best practices. It is getting to the point where our development process are becoming really similar, and many of the SDE do not need to review code for the majority of their deliverables, instead they are working on the framework (harnesses) and auditing. (Of course they still do look at the code because the love coding. But they usually don't need to)

• ernestrc

  yesterday at 7:46 PM

  That’s exactly why Rune is also a terminal multiplexer. Rune acts as a bridge between automated and manual programming. You can fuzzy-search for symbols and files and reference them right from the chat UI, without having to copy and paste. When the agent is working, it uses Rune’s symbol index and IDE-grade toolset instead of greping the codebase. It also gets compilation errors right after applying patches.

  And this is just the beginning. I think there’s so much more to explore in this space.

• lantry

  yesterday at 7:59 PM

  What about search, and "find usages", and other affordances for navigating the codebase? I know vi can search within a file, but I think with larger codebases you need something more powerful.

  • pmontra

    yesterday at 9:15 PM

    Emacs does it. I don't remember which package I'm using and my laptop is out of reach now, but it leverages LSP. However my point is that I never used that functionality in the last months. I discovered today that M-. doesn't work anymore. It's the key combination to jump to the definition of something. Of course I used to hit it all the times. Maybe I broke it weeks ago with some configuration change. To give you some context, I'm a web developer, frontend and backend, currently Ruby, Python, Vue. I've been doing this job for more than 30 years.

• ceehex

  yesterday at 8:45 PM

  vim buffers also work very well with agents

Do I have to use Rune Network? Can it can run offline?

• ernestrc

  yesterday at 8:05 PM

  Yes, you can disable it but if you don't login with your Rune account, it won't ever connect. You can also disable auto-joining, even if logged in, with the following config: https://github.com/unstablebuild/rune/blob/main/cmd/rune/run...

The idea of the reverse rug-pull is fantastic, I hope it will work out! The ways people abuse open-source is appalling, yet the risible funding that goes to open-source makes thing really difficult for everyone.

The whole write-up is quite interesting so I'll definitely try it out.

• ernestrc

  yesterday at 9:22 PM

  Thanks, I'm gathering that people are very excited about this. We'll post something in the coming weeks.

I have a couple of questions:

1. Wouldn't writing everything from scratch mean a huge waste of effort? And can they really expect to replicate a lot of functionality for C++, Java, Rust, etc. that in other IDEs relies on libraries and compilers external tools doing a lot of heavy lifting?

2. What is this quote about? :

> What has happened in parts of the open-source community over the past few years is appalling. Companies have built projects in the open, benefited from their users and contributors, and then changed the license once the project became valuable.

The build time claim in the blog post is dubious, part of the problem is CGO isn't fast, but also if build time was really a motivator the null build path is entirely unoptimized for objects with long build times:

cached null (no changes) build:

        ~github/unstablebuild/rune % make
        pre-commit not installed; skipping git hook setup
        cd cmd/buildstamp && CGO_ENABLED=1 go build  -ldflags="-X unstable.build/rune/internal/debug.Tag=$(git describe --tags) -X unstable.build/rune/internal/debug.Commit=$(git rev-parse --short HEAD) -X unstable.build/rune/internal/debug.BuildDate=2026-09-11T20:16:22Z  -X unstable.build/rune/internal/debug.Package=six" -o ../../bin/buildstamp
        cd cmd/extension_chaos && CGO_ENABLED=1 go build  -ldflags="-X unstable.build/rune/internal/debug.Tag=$(git describe --tags) -X unstable.build/rune/internal/debug.Commit=$(git rev-parse --short HEAD) -X unstable.build/rune/internal/debug.BuildDate=2026-09-11T20:16:22Z  -X unstable.build/rune/internal/debug.Package=six" -o ../../bin/extension_chaos
        cd cmd/extension_color_palette && CGO_ENABLED=1 go build  -ldflags="-X unstable.build/rune/internal/debug.Tag=$(git describe --tags) -X unstable.build/rune/internal/debug.Commit=$(git rev-parse --short HEAD) -X unstable.build/rune/internal/debug.BuildDate=2026-09-11T20:16:22Z  -X unstable.build/rune/internal/debug.Package=six" -o ../../bin/extension_color_palette
        cd cmd/extension_fuzzy_search && CGO_ENABLED=1 go build  -ldflags="-X unstable.build/rune/internal/debug.Tag=$(git describe --tags) -X unstable.build/rune/internal/debug.Commit=$(git rev-parse --short HEAD) -X unstable.build/rune/internal/debug.BuildDate=2026-09-11T20:16:22Z  -X unstable.build/rune/internal/debug.Package=six" -o ../../bin/extension_fuzzy_search
        cd cmd/extension_go && CGO_ENABLED=1 go build  -ldflags="-X unstable.build/rune/internal/debug.Tag=$(git describe --tags) -X unstable.build/rune/internal/debug.Commit=$(git rev-parse --short HEAD) -X unstable.build/rune/internal/debug.BuildDate=2026-09-11T20:16:22Z  -X unstable.build/rune/internal/debug.Package=six" -o ../../bin/extension_go
        cd cmd/extension_python && CGO_ENABLED=1 go build  -ldflags="-X unstable.build/rune/internal/debug.Tag=$(git describe --tags) -X unstable.build/rune/internal/debug.Commit=$(git rev-parse --short HEAD) -X unstable.build/rune/internal/debug.BuildDate=2026-09-11T20:16:22Z  -X unstable.build/rune/internal/debug.Package=six" -o ../../bin/extension_python
        cd cmd/extension_rtc && CGO_ENABLED=1 go build  -ldflags="-X unstable.build/rune/internal/debug.Tag=$(git describe --tags) -X unstable.build/rune/internal/debug.Commit=$(git rev-parse --short HEAD) -X unstable.build/rune/internal/debug.BuildDate=2026-09-11T20:16:22Z  -X unstable.build/rune/internal/debug.Package=six" -o ../../bin/extension_rtc
        cd cmd/extension_rust && CGO_ENABLED=1 go build  -ldflags="-X unstable.build/rune/internal/debug.Tag=$(git describe --tags) -X unstable.build/rune/internal/debug.Commit=$(git rev-parse --short HEAD) -X unstable.build/rune/internal/debug.BuildDate=2026-09-11T20:16:22Z  -X unstable.build/rune/internal/debug.Package=six" -o ../../bin/extension_rust
        cd cmd/extension_zig && CGO_ENABLED=1 go build  -ldflags="-X unstable.build/rune/internal/debug.Tag=$(git describe --tags) -X unstable.build/rune/internal/debug.Commit=$(git rev-parse --short HEAD) -X unstable.build/rune/internal/debug.BuildDate=2026-09-11T20:16:22Z  -X unstable.build/rune/internal/debug.Package=six" -o ../../bin/extension_zig
        cd cmd/runefox && CGO_ENABLED=1 go build  -ldflags="-X unstable.build/rune/internal/debug.Tag=$(git describe --tags) -X unstable.build/rune/internal/debug.Commit=$(git rev-parse --short HEAD) -X unstable.build/rune/internal/debug.BuildDate=2026-09-11T20:16:22Z  -X unstable.build/rune/internal/debug.Package=six" -o ../../bin/runefox
        cd cmd/sshshop && CGO_ENABLED=1 go build  -ldflags="-X unstable.build/rune/internal/debug.Tag=$(git describe --tags) -X unstable.build/rune/internal/debug.Commit=$(git rev-parse --short HEAD) -X unstable.build/rune/internal/debug.BuildDate=2026-09-11T20:16:22Z  -X unstable.build/rune/internal/debug.Package=six" -o ../../bin/sshshop
        cd cmd/walkbench && CGO_ENABLED=1 go build  -ldflags="-X unstable.build/rune/internal/debug.Tag=$(git describe --tags) -X unstable.build/rune/internal/debug.Commit=$(git rev-parse --short HEAD) -X unstable.build/rune/internal/debug.BuildDate=2026-09-11T20:16:22Z  -X unstable.build/rune/internal/debug.Package=six" -o ../../bin/walkbench
        make  35.90s user 5.88s system 191% cpu 21.846 total 1975848 rss

    ~github/zed-industries/zed % touch crates/zed/src/zed.rs
    ~github/zed-industries/zed % cargo build
       Compiling zed v1.18.0 (/home/raggi/src/github.com/zed-industries/zed/crates/zed)
       Finished `dev` profile [unoptimized + debuginfo] target(s) in 8.42s
    cargo build  10.15s user 9.34s system 228% cpu 8.531 total 7930312 rss

• marcopolo

  yesterday at 11:29 PM

  As a sibling comment pointed out this isn't comparing the same things. I'll try to provide a better comparison.

  On a warm build on my machine, after editing a string in Zed's `crates/zed/src/zed.rs` and editing a string in Rune's `./cmd/rune/main.go`

  Zed: `cargo build --release`: 284s (debug 30s)

  Rune: `go build ./cmd/rune`: 15s

  note I'm using a release build in Cargo to make it a bit fairer as all builds are "release" builds in Go.

• ernestrc

  yesterday at 9:30 PM

  You just compiled 9 extensions, a purpose built benchmark program, a toy ssh shop I built, a toy TUI browser and Rune, in serial. It's right there in the output. Try `go build ./cmd/rune` for a fair comparison.

• raggi

  yesterday at 8:31 PM

  Similar reflection, I ran `kitten __benchmark__ --render` in rune, the CPU time spent was 1:55. I ran the same in a libghostty based terminal emulator and spent 0:44 on CPU.

  I say this only because yes you can do engineering to meet the benchmark without dropping to deeper systems layers, but closing the gap on efficiency is hard. I'm not saying this to be a downer on your project - an IDE and VTE in Go are a fun project to have around, but the blog post makes implied claims of equivalence with moderate investment - but I think that's limited to single benchmark chasing. I say this as a polyglot who's day job is a Go based program that would be far easier to optimize in a systems language.

  • ernestrc

    yesterday at 9:36 PM

    If you're going to run a benchmark, at least post the results. I was planning on writing up a different blog post about the terminal optimization journey, but I actually used `kitten __benchmark__ --render` quite a lot to optimize it:

    rune --version Rune v1.2.1 (HEAD is 40bf9cc1)

    Results: Only ASCII chars : 1.13s @ 177.2 MB/s Unicode chars : 1.44s @ 123.2 MB/s CSI codes with few chars : 2.95s @ 33.9 MB/s Long escape codes : 6.25s @ 125.5 MB/s Images : 2.76s @ 193.1 MB/s

    /Applications/Alacritty.app/Contents/MacOS/alacritty --version alacritty 0.13.1 (fe2a3c5)

    Results: Only ASCII chars : 1.97s @ 101.4 MB/s Unicode chars : 1.26s @ 140.3 MB/s CSI codes with few chars : 1.26s @ 79.3 MB/s Long escape codes : 5.22s @ 150.1 MB/s Images : 1.34s @ 399.3 MB/s

    ghostty --version Ghostty 1.3.2-main-+aa21caeaa

    Results: Only ASCII chars : 354.9ms @ 563.5 MB/s Unicode chars : 815.42ms @ 217.0 MB/s CSI codes with few chars : 1.23s @ 81.6 MB/s Long escape codes : 6.39s @ 122.8 MB/s Images : 680.84ms @ 783.4 MB/s

    Ran just now, on a Macbook Pro M4 Max 128Gb.

    Rune doesn't support the kitty graphics protocol, so ignore the Images bench results.

[dead]

[dead]

[dead]

Lovely to see, this was my main gripe the last I saw it. Also great to see it under the GPLv3, and not some crap like MIT.