rickub
turbo-editors/turbo-gopublic Fork
⑂ main
Branches
main
Tags
v1.0.0 v1.0.1 v1.0.2 v1.0.3 v1.0.4 v1.0.5 View all branches → View all tags →
Commits
⬇ Clone ▾
git clone https://git.rickub.com/turbo-editors/turbo-go.git
git clone ssh://git@rickub.com/turbo-editors/turbo-go.git

Host key fingerprint (ed25519): SHA256:iycHnxEyq0Q7uyVpB7JlznP0G7JrTPXLYRcAU5CSLhc — verify it before your first connect.

Download ZIP
📦 Turbo Go b8a15b9 · on main · k33g · 14d ago
.github .memory .qlty .quality .tickets .turbo-go .vscode acp-agent demo docs internal scripts .gitignore 511 B 01-release.tag.sh 4.6 KB 02-build-releases.sh 7.3 KB INSTALL.MACOS.md 447 B LICENSE 1.0 KB Makefile 2.1 KB README.md 9.0 KB UPDATE.md 121 B git.sh 2.1 KB go.mod 894 B go.sum 5.5 KB install_test.go 10.9 KB main.go 8.8 KB main_test.go 5.6 KB new.branch.sh 55 B new.feature.sh 128 B new.fix.sh 115 B release.env 540 B release_test.go 21.5 KB ssh_test.go 2.5 KB version_check_test.go 5.9 KB
README.md

turbo-go

A Turbo C-style editor for Go, written in Go.

Built on turbo-core, the library every Turbo editor shares. What is in this repository is the command, the profile that says this editor is for Go, and the Go scanner — about four hundred lines. Everything else lives in the library.

A full-screen terminal IDE with the Borland furniture - a menu bar with hot keys, movable windows that cast shadows, modal dialogs, a clickable status bar — and the things a Go editor needs today: syntax colouring from the compiler's own tokeniser, loadable colour themes, completion from gopls, shell windows, per-project settings, a project tree, snippets, and the go toolchain a menu away.

 File  Edit  Search  Run  Options  Window  Help
╔═[x]═════════════════════════════ greeter.go ══════════════════════════════1═[■]╗
║ 1 package main                                                                ▲║
║ 2                                                                             ▓║
║ 3 import "fmt"                                                                ░║
║ 4                                                                             ░║
║ 5 // Greeter says hello to whoever asks.                                      ░║
║ 6 type Greeter struct {                                                       ░║
║ 7         Name  string                                                        ░║
║ 8         Count int                                                           ░║
║ 9 }                                                                           ▼║
║◄▓░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░►║
╚════════════════════════════════════════════════════════════════════════════════╝
 F1 Describe  F2 Save  F3 Open  F6 Window  F7 Next  F10 Menu          1:1  LSP: ready

Getting started

make install

That builds the editor, puts it where your shell looks for commands, and reports what it found — the Go version, where the binary went, whether that directory is on your PATH, and whether gopls is installed. Then, from any Go project:

turbo-go main.go

To build without installing, make build leaves the binary in bin/turbo-go. From the module proxy instead of a checkout: go install rickub.com/turbo-editors/turbo-go@latest.

For completion, install the Go language server as well — the editor works without it, and says so on the status bar:

go install golang.org/x/tools/gopls@latest

The tutorial walks through a first session in about ten minutes.

Features

  • Every build knows what it is — turbo-go -version and Help ▸ About name the version, the commit and the build date, stamped in by the linker from git describe rather than read from a constant somebody forgot to bump
  • Turbo Vision interface — menu bar with Alt-letter hot keys, overlapping movable and resizable windows, modal dialogs, mouse support throughout
  • Syntax colouring for nine languages — Go through go/scanner, so it is exactly as right as the compiler, plus TOML, Markdown, JavaScript, HTML and shell scripts from turbo-core, each with a small scanner of its own
  • Themes in TOML, eleven embedded — Borland navy, dark grey, paper white, espresso, Catppuccin Frappé and Latte, cobalt, Darcula and IntelliJ Light, and a hueless monochrome in both polarities — and any number of your own, with inheritance between files and between style keys. Every shipped theme is held to its contrast by tests
  • Per-project settings in .turbo-go/settings.toml — pin a theme, turn on automatic saving — created from a menu item and never by itself
  • Completion, hover and go-to-definition from gopls, entirely optional
  • Terminal windows — F8 opens a real shell in a window, with its own VT/ANSI emulator, scrollback and job control (Linux, macOS and Windows)
  • Project tree — F9 shows the project's files in a window; walk it with the arrows and press Enter to open one
  • Editing another machine — turbo-go -ssh user@machine[:dir] opens a project on a server, a VM or a container over your own ssh — its ~/.ssh/config, keys, agent or password — so the files, the tree, the terminal windows and the Go menu are that machine's. One login, before the screen is taken; no language server over there yet
  • Snippets — a Snippets menu built from .turbo-go/snippets.toml, grouped into submenus and filtered by the file you are in; the chosen text is inserted at the cursor, re-indented to match
  • The go toolchain a menu away — Alt-G runs format, vet, build, test and run from .turbo-go/tools.toml, each showing its output where the tool asked: a popup that fills in as it goes, a terminal window, or an editing window to search. Files the command rewrote are re-read for you, and a tool naming a menu of its own gets that menu on the bar
  • Editing with word movement, block indent, a shared clipboard, and undo that merges a run of typing into one step
  • Faithful files — line endings and the trailing newline are preserved, and saving is atomic
  • Automatic saving, off by default, writing a short while after you stop typing

Commands

Command What it does
make install Build and install onto your PATH
make build Compile into bin/turbo-go
make test Run the whole test suite
make check fmt, vet, then the tests — what a commit should pass
make run FILE=x.go Build and start the editor on a file
make help List every target 
turbo-go [-theme name] [-no-lsp] [file...]
turbo-go -list-themes
turbo-go -ssh user@machine[:directory] [file...]

Documentation

Full documentation in English and French, organised by the Diátaxis method:
Tutorial Your first file in Turbo Go
How-to install · run the tests · enable completion · write a theme · move around a file · use a terminal · configure a project · browse a project · use snippets · run go commands · make a release
Reference command line · keyboard · menus · theme format · terminal windows · project settings · project tree · languages · snippets · go tools · the version number
Explanation architecture · design decisions · colouring and completion · terminal windows · project settings · project tree · snippets · go tools

The library's packages each carry their own README.md beside the code, in turbo-core.

Where the code is
main.go flags, the terminal, the wiring
internal/golang the profile, the Go scanner, the three starter files
everything else turbo-core

The dependency graph is drawn in docs/diagrams/packages.drawio, checked against go list.

Design in one line

Two dependencies — tcell/v2 and BurntSushi/toml — and everything else from the standard library, including the tokeniser and the Language Server Protocol client. Both come through turbo-core; this repository adds none of its own. The design decisions page explains why.

Requirements

Go 1.26 or later. A terminal with mouse reporting, which is all of them. gopls is optional.

Licence

See LICENSE.