DEV Community: Andres Court

Create an API - Project Setup

Andres Court — Sat, 04 Apr 2026 15:39:17 +0000

In this new series we will be creating an API written in go, using a framework like Chi, connecting to a PostgreSQL, and have it deployed to a site like Railway.

The project will be hosted in GitHub

Requirements

In order to follow this tutorial, we will need to have the following installed:

The Go programing language, you can do this by following the instructions in the Go website
The PostgreSQL database, to install just follow the instructions in the PostgreSQL website
Git and GitHub for version control and remote repository
Railway Account so you will have a place to deploy the application

What are we going to be building

Through this tutorial, we will be creating an API which will be tracking a book store and store comments for each of the books.

We also will have a form of authentication, where we will sign in users, and with that we will implement a basic authorization module which will give some permissions to users.

We will be adding both unit and integration tests, so we can ensure that we are accomplishing each of the requirements of our MVP

Finally, each endpoint we will be creating should return the appropriate HTTP Code and the response will be using the JSON format

Setting up the project

Create the directory where we will be coding the application

mkdir bookstore
cd bookstore

Initialize Git for the project. It is my personal preference to add an empty commit as my initial commit

git init
git commit --allow-empty -m "Intial Commit"

Initialize the Go project

go mod init github.com/alcb1310/bookstore

On this step we created the go.mod file and added the posibility to add libraries to our project

API entry point. Now we will start using best practices on where to place each file. Even though your main file could be placed in the project's root, it is a good practice to save it inside the /cmd/api directory

mkidr -p cmd/api

Inside the /cmd/api folder we will create the main.go file as our application entry point

package main

import fmt

func main() {
    fmt.Println("Hello bookstore")
}

To run the project, you can execute

go run ./cmd/api/main.go

and the following will be displayed

Enabling Hot Reload

At the moment we have an entry point for our application, but we will need to stop and rerun manually each time we make changes in the application. There is a tool we can use and that one is Air, so let's setup it

Install Air in your system

go install github.com/air-verse/air@latest

To make sure you've installed air in your system run

air -v

Create a .air.toml configuration file, with this step we will setup some defaults for our project that will direct which file is your entry point

root = "."
tmp_dir = "tmp"

[build]
# Just plain old shell command. You could use `make` as well.
cmd = "go build -o ./build/main ./cmd/api/main.go"
# Entrypoint binary relative to root. First item is the executable, more items are default arguments.
entrypoint = ["./build/main"]
delay = 1000
# Ignore these filename extensions or directories.
exclude_dir = ["build"]
exclude_file = []
# Exclude specific regular expressions.
exclude_regex = ["_test\\.go"]
log = "build-errors.log"

[color]
# Customize each part's color. If no color found, use the raw app log.
main = "magenta"
watcher = "cyan"
build = "yellow"
runner = "green"

[misc]
clean_on_exit = true

[screen]
clear_on_rebuild = true
keep_scroll = true

Ignoring files for source contrl

As the final step in this article, there are files that we do not want to track its changes such as the binaries we will be generating, like the ones we will save in the build directory, we will need to create a .gitignore file for it

build
tmp

Adding our first route

Next step is to start using Chi, first we will need to add it to our project

go get -u github.com/go-chi/chi/v5

It is a best practice to have our entry point as small as possible and have each process split in different modules, so following that, we will create a router module

mkidr -p internal/router

The internal folder in Go makes that all the modules we create inside it, will not be visible from other projects, that is why we want to have our business logic inside it

internal/router/router.go

package router

import (
    "fmt"
    "log/slog"
    "net/http"

    "github.com/go-chi/chi/v5"
)

type service struct {
    port uint16
}

func New(port uint16) *service {
    return &service{
        port: port,
    }
}

func (s *service) Router() error {
    r := chi.NewRouter()

    r.Get("/", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("Hello world"))
    })

    port := fmt.Sprintf(":%d", s.port)
    slog.Info("Starting server", "port", port)
    return http.ListenAndServe(port, r)
}

cmd/api/main.go

package main

import "github.com/alcb1310/bookstore/internal/router"

func main() {
    var port uint16 = 8080

    s := router.New(port)
    if err := s.Router(); err != nil {
        panic(err)
    }
}

Reading from environment

Now we have our application working, but we have hardcoded the PORT in which the application will be listening to, to solve that we can use environment variables in a .env file at the root of our project.

To do so, we will first need to install a package

go get github.com/joho/godotenv

With that we can change our main.go file

main.go

...
import (
    "log/slog"
    "os"
    "strconv"
    ...
    _ "github.com/joho/godotenv/autoload"
)

func main() {
    port64, err := strconv.ParseUint(os.Getenv("PORT"), 10, 16)
    if err != nil {
        slog.Error("Error parsing port", "error", err)
        panic(err)
    }
    port := uint16(port64)

    ...
}

Deploying the application

Now we have the application it its most basic form, so it is a good idea to deploy it.

First we need to push all of our code to GitHub
In railway home page, we click in the deploy button

We select GitHub Repository and select the repo you are using

Select the repo and go to the settings tab

In the Networking section, select Generate Domain, and select the default PORT 8080

After its done, click on the link provided and you should be able to see the message we added to our route, meaning our project is deployed and running, and every change we make in the main branch in GitHub will be deployed in railway

Deploying PR

Railway has a feature where you can automatically deploy PR's, it is always a good idea to enable them so you can test your changes before merging them, you can find that option in the project's settings page under the Environments tab

Highlight Multiple Languages

Andres Court — Tue, 02 Dec 2025 02:13:27 +0000

The changes explained in this post can be found in the Kilo-go Github repository, in the multilingual branch.

At the moment, we have syntax highlighting but only for Go, and we want our editor to be able to highlight multiple languages. What do we want to achieve:

Highlight multiple languages
Multiple language support
Add new languages without editing the code

Refactor: move the syntax struct to its own package

First we will be moving the syntax struct to its own package so we have the methods we will be creating in it

File: sytnax/syntax.go

package syntax

import "github.com/alcb1310/kilo-go/utils"

var GO_HL_EXTENSIONS = []string{".go"}
var GO_HL_KEYWORDS = []string{"package", "import", "func", "type", "var", "const", "if", "else",
    "switch", "case", "default", "for", "range", "goto", "continue", "select", "return", "break",
}

var GO_HL_TYPES = []string{"bool", "byte", "error", "float32", "float64", "int", "int16", "int32",
    "int64", "int8", "rune", "string", "uint", "uint16", "uint32", "uint64", "uint8",
}

var GO_SYNTAX = EditorSyntax{
    Filetype:              "go",
    Filematch:             GO_HL_EXTENSIONS,
    Flags:                 utils.HL_HIGHLIGHT_NUMBER | utils.HL_HIGHLIGHT_STRING,
    SingleLineComment:     "//",
    MultiLineCommentStart: "/*",
    MultiLineCommentEnd:   "*/",
    Keywords:              GO_HL_KEYWORDS,
    Types:                 GO_HL_TYPES,
}

type EditorSyntax struct {
    Filetype              string
    Filematch             []string
    Flags                 uint
    SingleLineComment     string
    MultiLineCommentStart string
    MultiLineCommentEnd   string
    Keywords              []string
    Types                 []string
}

var HLDB = []EditorSyntax{
    GO_SYNTAX,
    C_SYNTAX,
}

File: editor/editor.go

type EditorConfig struct {
    ...
    syntax        *syntax.EditorSyntax
}

File: editor/output.go

func (e *EditorConfig) editorDrawStatusBar(abuf *ab.AppendBuffer) {
    ...
    if e.syntax != nil {
        filetype = "[" + e.syntax.Filetype + "]"
    }
    ...
}

File: editor/syntax.go

func (e *EditorConfig) editorUpdateSyntax(row *EditorRow) {
    ...
    scs := e.syntax.SingleLineComment
    mcs := e.syntax.MultiLineCommentStart
    mce := e.syntax.MultiLineCommentEnd
    keywords := e.syntax.Keywords
    types := e.syntax.Types
    ...
    i := 0
    for i < len(row.render) {
        ...

        if e.syntax.Flags&utils.HL_HIGHLIGHT_STRING == 2 {
            ...
        }

        if e.syntax.Flags&utils.HL_HIGHLIGHT_NUMBER == 1 {
            ...
        }
        ...
    }
    ...
}

func (e *EditorConfig) editorSelectSyntaxHighlight() {
    ...
    for i, s := range syntax.HLDB {
        isExt := s.Filematch[i][0] == '.'

        if (isExt && ext == s.Filematch[i]) ||
            (!isExt && strings.Contains(ext, s.Filematch[i])) {
            ...
        }
    }
}

Adding C/C++ support

Now the next step is to add support for another language, we will add C/C++

File: syntax/syntax.go

package syntax

type EditorSyntax struct {
    Filetype              string
    Filematch             []string
    Flags                 uint
    SingleLineComment     string
    MultiLineCommentStart string
    MultiLineCommentEnd   string
    Keywords              []string
    Types                 []string
}

var HLDB = []EditorSyntax{
    GO_SYNTAX,
    C_SYNTAX,
}

File: syntax/go.go

package syntax

import "github.com/alcb1310/kilo-go/utils"

var GO_HL_EXTENSIONS = []string{".go"}
var GO_HL_KEYWORDS = []string{"package", "import", "func", "type", "var", "const", "if", "else",
    "switch", "case", "default", "for", "range", "goto", "continue", "select", "return", "break",
}

var GO_HL_TYPES = []string{"bool", "byte", "error", "float32", "float64", "int", "int16", "int32",
    "int64", "int8", "rune", "string", "uint", "uint16", "uint32", "uint64", "uint8",
}

var GO_SYNTAX = EditorSyntax{
    Filetype:              "go",
    Filematch:             GO_HL_EXTENSIONS,
    Flags:                 utils.HL_HIGHLIGHT_NUMBER | utils.HL_HIGHLIGHT_STRING,
    SingleLineComment:     "//",
    MultiLineCommentStart: "/*",
    MultiLineCommentEnd:   "*/",
    Keywords:              GO_HL_KEYWORDS,
    Types:                 GO_HL_TYPES,
}

File: syntax/c.go

package syntax

import "github.com/alcb1310/kilo-go/utils"

var C_HL_EXTENSIONS []string = []string{".c", ".h", ".cpp"}

var C_SYNTAX = EditorSyntax{
    Filetype:              "c",
    Filematch:             C_HL_EXTENSIONS,
    Flags:                 utils.HL_HIGHLIGHT_NUMBER | utils.HL_HIGHLIGHT_STRING,
    SingleLineComment:     "//",
    MultiLineCommentStart: "/*",
    MultiLineCommentEnd:   "*/",
    Keywords: []string{"switch", "if", "while", "for", "break", "continue", "return", "else",
        "struct", "union", "typedef", "static", "enum", "class", "case", "#include", "#define", "#ifndef", "#ifdef", "#endif", "#else"},
    Types: []string{"int", "long", "double", "float", "char", "unsigned", "signed",
        "void"},
}

After testing we can see that there is a bug that we need to address, that's why we need to update:

File: editor/syntax.go

func (e *EditorConfig) editorSelectSyntaxHighlight() {
    ...
    for _, s := range syntax.HLDB {
        for j := range s.Filematch {
            isExt := s.Filematch[j][0] == '.'
            if (isExt && ext == s.Filematch[j]) ||
                (!isExt && strings.Contains(ext, s.Filematch[j])) {
                e.syntax = &s

                for _, row := range e.rows {
                    e.editorUpdateSyntax(&row)
                }

                return
            }
        }
    }

}

Multilingual support without changing the editor

Finally we have multilingual support, but what happens if we need to add another language, well, we will need to add a new file in the syntax package for that language with the fields required and recompile the application. I'm sure we can do better, in the editor's config directory we can create a highlight directory where we can add files with the required information, so lets do that

File: ${XDG_CONFIG}/kilo/highlight/go.toml

number=true
string=true
filetype="GO"
extensions=[".go"]
keywords=[ "package", "import", "func", "type", "var", "const", "if", "else",
    "switch", "case", "default", "for", "range", "goto", "continue", "select", "return", "break",
]
types=[ "bool", "byte", "error", "float32", "float64", "int", "int16", "int32", "nil",
    "int64", "int8", "rune", "string", "uint", "uint16", "uint32", "uint64", "uint8",
]
slc="//"
mlcs="/*"
mlce="*/"

File: ${XDG_CONFIG}/kilo/highlight/c.toml

number=true
string=true
filetype="C/CPP"
extensions=[".c", ".h", ".cpp"]
keywords=["switch", "if", "while", "for", "break", "continue", "return", "else",
        "struct", "union", "typedef", "static", "enum", "class", "case", "#include", "#define", "#ifndef", "#ifdef", "#endif", "#else"
]
types=["int", "long", "double", "float", "char", "unsigned", "signed",
        "void", "NULL"]
slc="//"
mlcs="/*"
mlce="*/"

File: main.go

func init() {
    ...
    syntax.LoadSyntax()
}

File: syntax/syntax.go

package syntax

import (
    "fmt"
    "os"
    "path"

    "github.com/BurntSushi/toml"
    "github.com/alcb1310/kilo-go/utils"
)

type EditorSyntax struct {
    Filetype              string   `toml:"filetype"`
    Filematch             []string `toml:"extensions"`
    Flags                 uint
    SingleLineComment     string `toml:"slc"`
    MultiLineCommentStart string `toml:"mlcs"`
    MultiLineCommentEnd   string `toml:"mlce"`
    Keywords              []string
    Types                 []string
    NumberFlag            bool `toml:"number"`
    StringFlag            bool `toml:"string"`
}

var HLDB = []EditorSyntax{}

func LoadSyntax() error {
    dir, err := os.UserConfigDir()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error: %s\r\n", err)
        return err
    }

    tomlDir := path.Join(path.Join(dir, "kilo"), "highlight")
    _, err = os.Stat(tomlDir)
    if err != nil {
        if os.IsNotExist(err) {
            return nil
        }

        fmt.Fprintf(os.Stderr, "Error: %s\r\n", err)
        return err
    }

    files, err := os.ReadDir(tomlDir)
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error: %s\r\n", err)
        return err
    }

    for _, file := range files {
        s := EditorSyntax{}
        if file.IsDir() {
            continue
        }

        _, err := toml.DecodeFile(path.Join(tomlDir, file.Name()), &s)
        if err != nil {
            fmt.Fprintf(os.Stderr, "Error: %s\r\n", err)
            return err
        }

        if s.NumberFlag {
            s.Flags |= utils.HL_HIGHLIGHT_NUMBER
        }

        if s.StringFlag {
            s.Flags |= utils.HL_HIGHLIGHT_STRING
        }

        HLDB = append(HLDB, s)
    }

    return nil
}

Adding Config File

Andres Court — Sat, 29 Nov 2025 16:41:46 +0000

On my previous posts, I've been creating a text editor based on the Kilo text Editor.

The changes explained in this post can be found in the Kilo-go github repository, in the config branch

Now we are going to improve it, and since we've finished the guide, I'm not going to continue with the series.

In this article we are going to go through the process of:

Being able to use in other operating systems and not only in Linux
Adding a configuration file so we can change some of the editor's behavior without changing the code

Multiplatform support

First thing we need to address is to be able to run the text editor in any operating system. Upon finishing the series, I found a library that will help us go to raw mode regardless of the operating system we are working in.

Note: I was able to test this feature in both MacOS and Linux, do not have a Windows machine for me to test in

Install the required dependency

The library that will help us with this is golang.org/x/term so let's proceed to install it

go get golang.org/x/term

Implementing the feature

Now that we have the library on our project, let's use it to go to raw mode

File: linux/raw.go

package linux

import (
    "fmt"
    "os"

    "github.com/alcb1310/kilo-go/utils"
    "golang.org/x/term"
)

func EnableRawMode() (func(), error) {
    oldState, err := term.MakeRaw(int(os.Stdin.Fd()))

    return func() {
        if err = term.Restore(int(os.Stdin.Fd()), oldState); err != nil {
            utils.SafeExit(nil, fmt.Errorf("EnableRawMode: error restoring terminal flags: %w", err))
        }
    }, err
}

File: utils/window.go

package utils

import (
    "os"

    "golang.org/x/term"
)

func GetWindowSize() (int, int, error) {
    return term.GetSize(int(os.Stdout.Fd()))
}

File: main.go

func init() {
    ...
    restoreFunc, err = linux.EnableRawMode()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error: %s\r\n", err)
        os.Exit(1)
    }
}

File: editor/editor.go

func NewEditor(f func()) *EditorConfig {
    cols, rows, err := utils.GetWindowSize()
    if err != nil {
        utils.SafeExit(f, err)
    }
    ...
}

This refactor doesn't only allows us to run the text editor in different platforms, but also simplified it a lot

Cleaning up unused libraries

Now that we've changed the library we use to go to enable raw mode, we need to remove unnecessary libraries

go mod tidy

Adding a configuration file

Next step in our process is to be able to configure the Text Editor using a configuration file, that way we can change the behavior without modifying the application

Using variables instead of constants

We will be using variables instead of constants so we can modify them with the ones in the configuration files, the values in that we assign on declaration will be the default behavior the application will have if no config file or if it is not set in the config.

File: utils/constants.go

var (
    KILO_TAB_STOP   int = 8
    KILO_QUIT_TIMES int = 3

    KILO_DEFAULT_COLOR [3]uint8 = [3]uint8{255, 255, 255}
    KILO_NUMBER_COLOR  [3]uint8 = [3]uint8{255, 0, 0}
    KILO_MATCH_COLOR   [3]uint8 = [3]uint8{51, 255, 0}
    KILO_STRING_COLOR  [3]uint8 = [3]uint8{255, 39, 155}
    KILO_COMMENT_COLOR [3]uint8 = [3]uint8{0, 255, 255}
    KILO_KEYWORD_COLOR [3]uint8 = [3]uint8{255, 239, 0}
    KILO_TYPE_COLOR    [3]uint8 = [3]uint8{126, 239, 55}
)

File: editor/syntax.go

func editorSyntaxToColor(hl utils.EditorHighlight) (r uint8, g uint8, b uint8) {
    switch hl {
    case utils.HL_NUMBER:
        r = utils.KILO_NUMBER_COLOR[0]
        g = utils.KILO_NUMBER_COLOR[1]
        b = utils.KILO_NUMBER_COLOR[2]
    case utils.HL_MATCH:
        r = utils.KILO_MATCH_COLOR[0]
        g = utils.KILO_MATCH_COLOR[1]
        b = utils.KILO_MATCH_COLOR[2]
    case utils.HL_STRING:
        r = utils.KILO_STRING_COLOR[0]
        g = utils.KILO_STRING_COLOR[1]
        b = utils.KILO_STRING_COLOR[2]
    case utils.HL_COMMENT, utils.HL_MLCOMMENT:
        r = utils.KILO_COMMENT_COLOR[0]
        g = utils.KILO_COMMENT_COLOR[1]
        b = utils.KILO_COMMENT_COLOR[2]
    case utils.HL_KEYWORD:
        r = utils.KILO_KEYWORD_COLOR[0]
        g = utils.KILO_KEYWORD_COLOR[1]
        b = utils.KILO_KEYWORD_COLOR[2]
    case utils.HL_TYPE_KEYWORD:
        r = utils.KILO_TYPE_COLOR[0]
        g = utils.KILO_TYPE_COLOR[1]
        b = utils.KILO_TYPE_COLOR[2]
    default:
        r = utils.KILO_DEFAULT_COLOR[0]
        g = utils.KILO_DEFAULT_COLOR[1]
        b = utils.KILO_DEFAULT_COLOR[2]
    }
    return
}

Reading a `TOML` file

We now have to be able to read a .toml file, file in which we will be able to save any configuration variables that we will be creating. To do so we will be using the github.com/BurntSushi/toml library, so let's install it

go get github.com/BurntSushi/toml

File: utils/toml.go

package utils

import (
    "fmt"
    "os"
    "path"

    "github.com/BurntSushi/toml"
)

type Settings struct {
    QuitTimes int `toml:"quit_times"`
    TabStop   int `toml:"tab_stop"`
}

type TomlConfig struct {
    Settings Settings
    Theme    map[string][3]uint8
}

func LoadTOML() error {
    var config TomlConfig = TomlConfig{}
    dir, err := os.UserConfigDir()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error: %s\r\n", err)
        return err
    }

    if err = os.MkdirAll(path.Join(dir, "kilo"), 0o755); err != nil {
        fmt.Fprintf(os.Stderr, "Error: %s\r\n", err)
        return err
    }

    filepath := path.Join(dir, "kilo", "config.toml")
    if _, err = os.Stat(filepath); os.IsNotExist(err) {
        return nil
    }

    _, err = toml.DecodeFile(filepath, &config)
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error: %s\r\n", err)
        return err
    }

    return nil
}

os.UserConfigDir() will return the user configuration directory, in Linux like systems will return the .config folder inside the user's home directory

os.MkdirAll() will create a directory if it doesn't exists, if it does exists it will do nothing returning nil for an error

File: main.go

func init() {
    ...
    utils.LoadTOML()
}

File: ${XDG_CONFIG}/kilo/config.toml

[settings]
tab_stop = 2
quit_times = 2

[theme]
comment=[0,25,255]
default=[240,240, 240]
keyword=[255,239,0]
number=[255,0,0]
search=[51,255,0]
string=[255,39,155]
type=[12,239,55]

Assigning the values

The final step is to assign these values to their respective variables within the application. It is important to note that we've created values that will flag if the config file is modifying a variable

File: utils/toml.go

func LoadTOML() error {
    var config TomlConfig = TomlConfig{
        Settings: Settings{
            QuitTimes: -1,
            TabStop:   -1,
        },
    }
    ...
    if config.Settings.QuitTimes >= 0 {
        KILO_QUIT_TIMES = config.Settings.QuitTimes
    }
    if config.Settings.TabStop >= 0 {
        KILO_TAB_STOP = config.Settings.TabStop
    }

    var val [3]uint8
    var ok bool

    if val, ok = config.Theme["default"]; ok {
        KILO_DEFAULT_COLOR = val
    }
    if val, ok = config.Theme["number"]; ok {
        KILO_NUMBER_COLOR = val
    }
    if val, ok = config.Theme["match"]; ok {
        KILO_MATCH_COLOR = val
    }
    if val, ok = config.Theme["string"]; ok {
        KILO_STRING_COLOR = val
    }
    if val, ok = config.Theme["comment"]; ok {
        KILO_COMMENT_COLOR = val
    }
    if val, ok = config.Theme["keyword"]; ok {
        KILO_KEYWORD_COLOR = val
    }
    if val, ok = config.Theme["type"]; ok {
        KILO_TYPE_COLOR = val
    }
    ...
}

Create a Text Editor in Go - Syntax Highlighting

Andres Court — Tue, 25 Nov 2025 02:05:48 +0000

You can access the code of this chapter in the Kilo-Go github repository in the syntax branch.

Currently your file structure should look something like this:

Now that we have a functional text editor, we will do the last step in this tutorial, and that is add syntax highlighting

Colorful digits

Let's start by having some color, we will highlight numbers by coloring each digit red.

File: utils/digits.go

package utils

func IsDigit(c byte) bool {
    return c >= '0' && c <= '9'
}

File: editor/output.go

func (e *EditorConfig) editorDrawRows(abuf *ab.AppendBuffer) {
    for y := range e.screenrows {
        filerow := y + e.rowoffset
        if filerow >= e.numrows {
            ...
        } else {
            chars := e.rows[filerow].render
            ...
            for j := range chars {
                if utils.IsDigit(chars[j]) {
                    fmt.Fprintf(abuf, "%c[38;2;255;0;0m", utils.ESC)

                    fmt.Fprintf(abuf, "%c", chars[j])
                    fmt.Fprintf(abuf, "%c[39m", utils.ESC)
                } else {
                    fmt.Fprintf(abuf, "%c", chars[j])
                }
            }
        }
        ...
    }
}

Note: the <Esc> [ 30 m through the <Esc> [ 37 m sequences define the text color, being 30 black and 37 white, and the <Esc> [ 39 m will reset the color back to normal.
To use RGB colors in text you can use <Esc> [ 38 ; 2 ; <Red> ; <Green> ; <Blue> m

Refactor syntax highlighting

Now that we know how to color text, we need to find a way that we save the highlights for each row before we display it

File: utils/constants.go

type EditorHighlight int

const (
    HL_NORMAL EditorHighlight = iota
    HL_NUMBER
)

Note: since Go doesn't have enums we are simulating it by the use of the EditorHighlight type

File: editor/editor.go

type EditorRow struct {
    ...
    hl     []utils.EditorHighlight
}

File: editor/row.go

func (e *EditorConfig) editorUpdateRow(row *EditorRow) {
    for j := 0; j < len(row.chars); j++ {
        ...
    }

    editorUpdateSyntax(row)
}

func (e *EditorConfig) editorInsertRow(at int, s string) {
    e.rows = append(e.rows[:at], append([]EditorRow{{chars: s}}, e.rows[at:]...)...)

    e.rows[at].hl = nil
    e.numrows++
    e.isDirty = true
}

File: editor/row.go

func (e *EditorConfig) editorDrawRows(abuf *ab.AppendBuffer) {
    for y := range e.screenrows {
        filerow := y + e.rowoffset
        if filerow >= e.numrows {
            ...
        } else {
            ...
            for j := range chars {
                r, g, b := editorSyntaxToColor(e.rows[filerow].hl[j])
                fmt.Fprintf(abuf, "%c[38;2;%d;%d;%dm", utils.ESC, r, g, b)
                fmt.Fprintf(abuf, "%c", chars[j])
            }
            fmt.Fprintf(abuf, "%c[39m", utils.ESC)
        }
        ...
    }
}

File: editor/syntax.go

package editor

import "github.com/alcb1310/kilo-go/utils"

func editorUpdateSyntax(row *EditorRow) {
    row.hl = make([]utils.EditorHighlight, len(row.render))

    for i := range len(row.render) {
        if utils.IsDigit(row.render[i]) {
            row.hl[i] = utils.HL_NUMBER
        }
    }
}

func editorSyntaxToColor(hl utils.EditorHighlight) (r uint8, g uint8, b uint8) {
    switch hl {
    case utils.HL_NUMBER:
        return 255, 0, 0
    case utils.HL_NORMAL:
        return 255, 255, 255
    default:
        return 255, 255, 255
    }
}

Colorful search results

Now that we've refactored our code to have the ability to highlight, lets change the text color of a search query

File: utils/constants.go

const (
    HL_NORMAL EditorHighlight = iota
    HL_NUMBER
    HL_MATCH
)

File: editor/syntax.go

func editorSyntaxToColor(hl utils.EditorHighlight) (r uint8, g uint8, b uint8) {
    switch hl {
    ...
    case utils.HL_MATCH:
        return 0, 0, 255
    ...
    }
}

File: editor/output.go

func (e *EditorConfig) editorDrawRows(abuf *ab.AppendBuffer) {
    for y := range e.screenrows {
        filerow := y + e.rowoffset
        if filerow >= e.numrows {
            ...
        } else {
            ...
            for j := range render {
                r, g, b := editorSyntaxToColor(e.rows[filerow].hl[j])
                fmt.Fprintf(abuf, "%c[38;2;%d;%d;%dm", utils.ESC, r, g, b)
                fmt.Fprintf(abuf, "%c", render[j])
            }
            fmt.Fprintf(abuf, "%c[39m", utils.ESC)

        }
        ...
    }
}

File: editor/find.go

func (e *EditorConfig) editorFindCallback(query string, key int) {
    ...
    for range e.numrows {
        ...
        if strings.Contains(row.chars, query) {
            ...
            rx := editorRowCxToRx(row, e.cx)
            j := rx
            for i := 0; i < len(query); i++ {
                row.hl[j] = utils.HL_MATCH
                j++
            }
            return
        }
    }
}

File: editor/row.go

func (e *EditorConfig) editorAppendRow(s string) {
    row := EditorRow{
        chars:  s,
        render: make([]byte, 0),
    }
    ...
}

Restore syntax highlighting after search

Now when we've highlighted the search term, we want that once we finish the search the text will not be highlighted

File: editor/find.go

var saved_hl_line uint = 0
var saved_hl []utils.EditorHighlight = nil

func (e *EditorConfig) editorFindCallback(query string, key int) {
    if saved_hl_line != 0 {
        copy(e.rows[saved_hl_line].hl, saved_hl)
        saved_hl = nil
    }
    ...
    for range e.numrows {
        ...
        if strings.Contains(row.chars, query) {
            saved_hl_line = uint(current)
            saved_hl = make([]utils.EditorHighlight, len(row.render))
            copy(saved_hl, row.hl)
            ...
        }
    }
}

Colorful numbers

Currently we are highlighting every digit regardless if it is part of an expression (eg. in uint8 we are highlighting the 8) or if it is a number. We just want to highlight the digits only if it is a number

File: utils/constants.go

const (
    ...
    KILO_DECIMAL_SEPARATOR      = '.'
)

File: utils/digits.go

func IsSeparator(c byte) bool {
    return IsSpace(c) || strings.ContainsRune(",.()+-/*=~%<>[];{}", rune(c))
}

func IsSpace(c byte) bool {
    return c == ' ' || c == '\t' || c == '\n' || c == '\r'
}

File: editor/syntax.go

func editorUpdateSyntax(row *EditorRow) {
    prevSep := true
    row.hl = make([]utils.EditorHighlight, len(row.render))

    i := 0
    for i < len(row.render) {
        c := row.render[i]
        var prevHL utils.EditorHighlight
        if i > 0 {
            prevHL = row.hl[i-1]
        } else {
            prevHL = utils.HL_NORMAL
        }

        if utils.IsDigit(c) &&
            (prevSep || prevHL == utils.HL_NUMBER) ||
            (c == utils.KILO_DECIMAL_SEPARATOR && prevHL == utils.HL_NUMBER) {
            row.hl[i] = utils.HL_NUMBER
            i++
            prevSep = false
            continue
        }

        prevSep = utils.IsSeparator(c)
        i++
    }
}

Detect filetype

No we want to detect what filetype are we opening so we can apply the different highlight options for it

File: utils/constants.go

const (
    HL_HIGHLIGHT_NUMBER = (1 << 0)
)

File: editor/editor.go

type EditorSyntax struct {
    filetype  string
    filematch []string
    flags     uint
}

var GO_HL_EXTENSIONS = []string{".go"}
var HLDB = []EditorSyntax{
    {"go", GO_HL_EXTENSIONS, utils.HL_HIGHLIGHT_NUMBER},
}

type EditorConfig struct {
    ...
    syntax        *EditorSyntax
}

func NewEditor(f func()) *EditorConfig {
    ...
    return &EditorConfig{
        ...
        syntax:        nil,
    }
}

File: editor/syntax.go

func (e *EditorConfig) editorUpdateSyntax(row *EditorRow) {
    ...
    if e.syntax == nil {
        return
    }

    i := 0
    for i < len(row.render) {
        ...
        if e.syntax.flags&utils.HL_HIGHLIGHT_NUMBER == 1 {
            if utils.IsDigit(c) &&
                (prevSep || prevHL == utils.HL_NUMBER) ||
                (c == utils.KILO_DECIMAL_SEPARATOR && prevHL == utils.HL_NUMBER) {
                row.hl[i] = utils.HL_NUMBER
                i++
                prevSep = false
                continue
            }
        }
        ...
    }
}

func (e *EditorConfig) editorSelectSyntaxHighlight() {
    e.syntax = nil
    if e.filename == "" {
        return
    }

    lastIndex := strings.LastIndex(e.filename, ".")
    if lastIndex == -1 {
        return
    }
    ext := e.filename[lastIndex:]

    for i, s := range HLDB {
        isExt := s.filematch[i][0] == '.'

        if (isExt && ext == s.filematch[i]) ||
            (!isExt && strings.Contains(ext, s.filematch[i])) {
            e.syntax = &s

            for _, row := range e.rows {
                e.editorUpdateSyntax(&row)
            }

            return
        }
    }
}

File: editor/row.go

func (e *EditorConfig) editorUpdateRow(row *EditorRow) {
    ...
    e.editorUpdateSyntax(row)
}

File: editor/output.go

func (e *EditorConfig) editorDrawStatusBar(abuf *ab.AppendBuffer) {
    ...
    filetype := "[no ft]"
    if e.syntax != nil {
        filetype = "[" + e.syntax.filetype + "]"
    }
    ...
    rstatus := fmt.Sprintf("%s | column: %d row: %d/%d ", filetype, e.rx+1, e.cy+1, e.numrows)
    ...
}

File: editor/file.go

func (e *EditorConfig) editorOpen(filename string) {
    ...
    e.filename = filename
    e.editorSelectSyntaxHighlight()
    ...
}

func (e *EditorConfig) editorSave() {
    if e.filename == "" {
        ...
        e.editorSelectSyntaxHighlight()
    }
    ...
}

Colorful strings

Our next step will be recognizing strings and highlighting them

File: utils/constants.go

const (
    HL_HIGHLIGHT_NUMBER = (1 << 0)
    HL_HIGHLIGHT_STRING = (1 << 1)
)
...
const (
    HL_NORMAL EditorHighlight = iota
    HL_STRING
    ...
)

File: editor/editor.go

var HLDB = []EditorSyntax{
    {
        "go",
        GO_HL_EXTENSIONS,
        utils.HL_HIGHLIGHT_NUMBER | utils.HL_HIGHLIGHT_STRING,
    },
}

File: editor/syntax.go

func (e *EditorConfig) editorUpdateSyntax(row *EditorRow) {
    ...
    var inString byte = 0
    ...
    for i < len(row.render) {
        ...
        if e.syntax.flags&utils.HL_HIGHLIGHT_STRING == 2 {
            if inString != 0 {
                row.hl[i] = utils.HL_STRING
                if c == '\\' && i+1 < len(row.render) {
                    i++
                    row.hl[i] = utils.HL_STRING
                    i++
                    continue
                }
                if c == inString {
                    inString = 0
                }
                i++
                prevSep = true
                continue
            } else {
                if c == '"' || c == '\'' {
                    inString = c
                    row.hl[i] = utils.HL_STRING
                    i++
                    continue
                }
            }
        }
        ...
    }
}

func editorSyntaxToColor(hl utils.EditorHighlight) (r uint8, g uint8, b uint8) {
    r = 255
    g = 255
    b = 255

    switch hl {
    case utils.HL_NORMAL:
        return
    case utils.HL_NUMBER:
        g = 0
        b = 0
        return
    case utils.HL_MATCH:
        r = 51
        b = 0
        return
    case utils.HL_STRING:
        g = 39
        b = 155
        return
    default:
        return
    }
}

Colorful comments

Now we want to add color to the comments

File: utils/constants.go

const (
    HL_NORMAL EditorHighlight = iota
    HL_COMMENT
    ...
)

File: editor/editor.go

type EditorSyntax struct {
    ...
    singleLineComment string
}

var HLDB = []EditorSyntax{
    {
        filetype:          "go",
        filematch:         GO_HL_EXTENSIONS,
        flags:             utils.HL_HIGHLIGHT_NUMBER | utils.HL_HIGHLIGHT_STRING,
        singleLineComment: "//",
    },
}

File: editor/syntax.go

func (e *EditorConfig) editorUpdateSyntax(row *EditorRow) {
    ...
    scs := e.syntax.singleLineComment
    ...
    for i < len(row.render) {
        ...
        if len(scs) > 0 && inString == 0 {
            if strings.HasPrefix(string(row.render[i:]), scs) {
                for j := i; j < len(row.render); j++ {
                    row.hl[j] = utils.HL_COMMENT
                }
                break
            }
        }
        ...
    }
}

func editorSyntaxToColor(hl utils.EditorHighlight) (r uint8, g uint8, b uint8) {
    ...
    switch hl {
    ...
    case utils.HL_COMMENT:
        r = 0
        return
    ...
    }
}

Note: To disable comment highlight, just set the single line comment to an empty string

Colorful keywords

Now it's turn to highlight keywords, since Go is a strong typed language we will be using two colors:

First color for the actual keywords
Second color for the type names

File: utils/constants.go

const (
    HL_NORMAL EditorHighlight = iota
    ...
    HL_KEYWORD
    HL_TYPE_KEYWORD
    ...
)

File: utils/digits.go

func IsSeparator(c byte) bool {
    return IsSpace(c) || strings.ContainsRune(":,.()+-/*=~%<>[];{}", rune(c)) || rune(c) == 0
}

File: editor/editor.go

type EditorSyntax struct {
    ...
    keywords          []string
    types             []string
}
...
var GO_HL_KEYWORDS = []string{
    "package",
    "import",
    "func",
    "type",
    "var",
    "const",
    "if",
    "else",
    "switch",
    "case",
    "default",
    "for",
    "range",
    "goto",
    "continue",
    "select",
    "return",
    "break",
}

var GO_HL_TYPES = []string{
    "bool",
    "byte",
    "error",
    "float32",
    "float64",
    "int",
    "int16",
    "int32",
    "int64",
    "int8",
    "rune",
    "string",
    "uint",
    "uint16",
    "uint32",
    "uint64",
    "uint8",
}

var HLDB = []EditorSyntax{
    {
        ...
        keywords:          GO_HL_KEYWORDS,
        types:             GO_HL_TYPES,
    },
}

File: editor/operations.go

func (e *EditorConfig) editorInsertNewline() {
    if e.cy == len(e.rows) {
        ...
    } else {
        ...
        row.render = make([]byte, 0)
        ...
        row.render = make([]byte, 0)
        ...
    }
    ...
}

File: editor/row.go

func (e *EditorConfig) editorRowInsertChar(row *EditorRow, at int, c byte) {
    row.render = make([]byte, 0)
    ...
}

func (e *EditorConfig) editorRowDeleteChar(row *EditorRow, at int) {
    ...
    row.render = make([]byte, 0)
    ...
}

func (e *EditorConfig) editorRowAppendString(row *EditorRow, s string) {
    ...
    row.render = make([]byte, 0)
    ...
}

File: editor/syntax.go

func (e *EditorConfig) editorUpdateSyntax(row *EditorRow) {
    ...
    keywords := e.syntax.keywords
    types := e.syntax.types
    ...
    for i < len(row.render) {
        ...
        if prevSep {
            j := 0
            for j = 0; j < len(keywords); j++ {
                key := keywords[j]
                if strings.HasPrefix(string(row.render[i:]), key) &&
                    ((i+len(key) < len(row.render) &&
                        utils.IsSeparator(row.render[i+len(key)])) ||
                        i+len(key) == len(row.render)) {
                    for k := range key {
                        row.hl[i+k] = utils.HL_KEYWORD
                    }
                    i += len(key) - 1
                    break
                }
            }

            if j < len(keywords) {
                prevSep = false
                continue
            }

            m := 0
            for m = 0; m < len(types); m++ {
                key := types[m]
                if strings.HasPrefix(string(row.render[i:]), key) &&
                    ((i+len(key) < len(row.render) &&
                        utils.IsSeparator(row.render[i+len(key)])) ||
                        i+len(key) == len(row.render)) {
                    for k := range key {
                        row.hl[i+k] = utils.HL_TYPE_KEYWORD
                    }
                    i += len(key) - 1
                    break
                }
            }

            if m < len(types) {
                prevSep = false
                continue
            }
        }

        prevSep = utils.IsSeparator(c)
        i++
    }
}

func editorSyntaxToColor(hl utils.EditorHighlight) (r uint8, g uint8, b uint8) {
    r = 255
    g = 255
    b = 255

    switch hl {
    case utils.HL_NUMBER:
        g = 0
        b = 0
    case utils.HL_MATCH:
        r = 51
        b = 0
    case utils.HL_STRING:
        g = 39
        b = 155
    case utils.HL_COMMENT:
        r = 0
    case utils.HL_KEYWORD:
        g = 239
        b = 0
    case utils.HL_TYPE_KEYWORD:
        g = 55
        b = 239
        r = 126
    }
    return
}

Multiline comments

Finally we will highlight multiline comments, and we will have it have the same color as the single line comments

File: utils/constants.go

const (
    HL_NORMAL EditorHighlight = iota
    ...
    HL_MLCOMMENT
    ...
)

File: editor/editor.go

type EditorSyntax struct {
    ...
    multiLineCommentStart string
    multiLineCommentEnd   string
    ...
}

var HLDB = []EditorSyntax{
    {
        ...
        multiLineCommentStart: "/*",
        multiLineCommentEnd:   "*/",
        ...
    },
}

type EditorRow struct {
    idx           int
    hlOpenComment bool
    ...
}

File: editor/row.go

func (e *EditorConfig) editorUpdateRow(row *EditorRow) {
    ...
    row.idx = e.numrows
    ...
}

func (e *EditorConfig) editorRowDeleteChar(row *EditorRow, at int) {
    ...
    for j := at; j <= e.numrows-1; j++ {
        e.rows[j].idx--
    }
    ...
}

func (e *EditorConfig) editorInsertRow(at int, s string) {
    ...
    for j := at + 1; j <= e.numrows; j++ {
        e.rows[j].idx++
    }

    e.rows[at].idx = at
    ...
}

File: editor/syntax.go

func (e *EditorConfig) editorUpdateSyntax(row *EditorRow) {
    ...
    inComment := row.idx > 0 && e.rows[row.idx-1].hlOpenComment
    ...
    scs := e.syntax.singleLineComment
    mcs := e.syntax.multiLineCommentStart
    mce := e.syntax.multiLineCommentEnd
    ...

    scsLen := len(scs)
    mcsLen := len(mcs)
    mceLen := len(mce)

    i := 0
    for i < len(row.render) {
        ...
        if scsLen > 0 && inString == 0 && !inComment {
            ...
        }

        if mcsLen > 0 && mceLen > 0 && inString == 0 {
            if inComment {
                row.hl[i] = utils.HL_COMMENT
                if strings.HasPrefix(string(row.render[i:]), mce) {
                    for j := i; j < mceLen; j++ {
                        row.hl[j] = utils.HL_COMMENT
                    }
                    i += mceLen
                    inComment = false
                    prevSep = true
                    continue
                } else {
                    i++
                    continue
                }
            } else if strings.HasPrefix(string(row.render[i:]), mcs) {
                for j := i; j < mcsLen; j++ {
                    row.hl[j] = utils.HL_COMMENT
                }
                i += mcsLen
                inComment = true
                continue
            }
        }
        ...
    }

    changed := row.hlOpenComment != inComment
    row.hlOpenComment = inComment

    if changed && row.idx+1 < e.numrows {
        e.editorUpdateSyntax(&e.rows[row.idx+1])
    }
}

func editorSyntaxToColor(hl utils.EditorHighlight) (r uint8, g uint8, b uint8) {
    ...
    switch hl {
    ...
    case utils.HL_COMMENT, utils.HL_MLCOMMENT:
        r = 0
    ...
    }
    return
}

Finally we have completed the tutorial on a basic text editor, in future posts we will be going through on improving it with a serious features.

Create a Text Editor in Go - Search

Andres Court — Thu, 20 Nov 2025 03:40:44 +0000

You can access the code of this chapter in the Kilo-Go github repository in the search branch.

Currently your file structure should look something like this:

We have now a functional text editor, we could even continue writing the code for this project in it

Search

Let's use editorPrompt to implement a minimal search feature. When the user types a search query and presses Enter, we'll loop through the text, and if a row contains the query string, we'll move the cursor there

File: utils/constants.go

const (
    ...
    KILO_DEFAULT_STATUS_MESSAGE = "HELP: Ctrl-S = save | Ctrl-Q = quit | Ctrl-F = find"
)

File: utils/find.go

package editor

import (
    "strings"
)

func (e *EditorConfig) editorFind() {
    query := e.editorPrompt("Search: ")
    if query == "" {
        return
    }

    for i := range e.numrows {
        row := &e.rows[i]
        if strings.Contains(row.chars, query) {
            e.cy = i
            e.cx = strings.Index(row.chars, query)
            return
        }
    }
}

File: editor/input.go

func (e *EditorConfig) editorProcessKeypress() {
    ...
    switch b {
    ...
    case utils.CtrlKey('f'):
        e.editorFind()
        e.editorSetStatusMessage(utils.KILO_DEFAULT_STATUS_MESSAGE)
    ...
    }
    ...
}

Refactor: Have `editorPrompt` to take a callback

In order for us to be able to implement an Incremental Search, so we can execute some code when we need

File: utils/constants

type Callback func(query string, key int)

File: editor/input.go

func (e *EditorConfig) editorPrompt(prompt string, callback utils.Callback) string {
    ...
        ...
        switch b {
        ...
        case utils.ENTER:
            e.editorSetStatusMessage(utils.KILO_DEFAULT_STATUS_MESSAGE)
            if callback != nil {
                slog.Info("editorPrompt, calling callback")
            }
            return buf
        ...
}

File: editor/find.go

func (e *EditorConfig) editorFind() {
    query := e.editorPrompt("Search: ", nil)
    ...
}

File: editor/file.go

func (e *EditorConfig) editorSave() {
    if e.filename == "" {
        e.filename = e.editorPrompt("Save as: ", nil)
        if e.filename == "" {
            e.editorSetStatusMessage("Save aborted")
            return
        }
    }
    ...
}

Incremental search

Now let's move the actual searching to a new function that will be called by our callback function

File: editor/find.go

func (e *EditorConfig) editorFind() {
    query := e.editorPrompt("Search: ", e.editorFindCallback)
    if query == "" {
        return
    }

}

func (e *EditorConfig) editorFindCallback(query string, key int) {
    if key == utils.ENTER || key == utils.ESC {
        return
    }

    for i := range e.numrows {
        row := &e.rows[i]
        if strings.Contains(row.chars, query) {
            e.cy = i
            e.cx = strings.Index(row.chars, query)
            return
        }
    }
}

File: editor/input.go

func (e *EditorConfig) editorPrompt(prompt string, callback utils.Callback) string {
    ...
    for {
        ...
        switch b {
        ...
        case utils.ESC:
            slog.Info("editorPrompt, ESC")
            e.editorSetStatusMessage(utils.KILO_DEFAULT_STATUS_MESSAGE)
            if callback != nil {
                callback(buf, b)
            }
            return ""
        case utils.ENTER:
            e.editorSetStatusMessage(utils.KILO_DEFAULT_STATUS_MESSAGE)
            if callback != nil {
                callback(buf, b)
            }
            return buf
        ...
        }

        if callback != nil {
            callback(buf, b)
        }
    }
}

Restoring cursor position when canceling query

At the moment if the user cancels the query will be left at whatever position the incremental search left them, we want to make it so it returns to where ever they were

File: editor/find.go

func (e *EditorConfig) editorFind() {
    cx := e.cx
    cy := e.cy
    colloffset := e.colloffset
    rowoffset := e.rowoffset

    query := e.editorPrompt("Search: ", e.editorFindCallback)
    if query == "" {
        e.cx = cx
        e.cy = cy
        e.colloffset = colloffset
        e.rowoffset = rowoffset
    }
}

Search forward and backward

At the moment we can only find the first match it can find, let's add a feature to advance to the next or previous match.

The Up Arrow and Left Arrow keys will go to the previous match
The Down Arrow and Right Arrow keys will go to the next match

File: editor/input.go

func (e *EditorConfig) editorPrompt(prompt string, callback utils.Callback) string {
    ...
    for {
        ...
        switch b {
        ...
        default:
            if !utils.IsCtrlKey(b) && b < 128 {
                buf += string(rune(b))
            }
        }
        ...
    }
}

File: editor/find.go

// lastMatch is the index of the row that the last match was on
// or -1 if there was no match
var lastMatch int = -1

// direction will store the direction of the search:
// 1 for forward, -1 for backward
var direction int = 1

func (e *EditorConfig) editorFindCallback(query string, key int) {
    if key == utils.ENTER || key == utils.ESC {
        lastMatch = -1
        direction = 1
        return
    }

    switch key {
    case utils.ARROW_DOWN, utils.ARROW_RIGHT:
        direction = 1
    case utils.ARROW_UP, utils.ARROW_LEFT:
        direction = -1
    default:
        lastMatch = -1
        direction = 1
    }

    if lastMatch == -1 {
        direction = 1
    }
    current := lastMatch
    for range e.numrows {
        current += direction
        switch current {
        case -1:
            current = e.numrows - 1
        case e.numrows:
            current = 0
        }

        row := &e.rows[current]
        if strings.Contains(row.chars, query) {
            lastMatch = current
            e.cy = current
            e.cx = strings.Index(row.chars, query)
            e.rowoffset = e.numrows
            return
        }
    }
}

Create a Text Editor in Go - A Text Editor

Andres Court — Mon, 17 Nov 2025 04:21:39 +0000

You can access the code of this chapter in the Kilo-Go github repository in the texteditor branch.

Currently your file structure should look something like this:

Insert ordinary characters

First we want to be able to insert new characters, and if needed to be able to create a new line

File: editor/input.go

func (e *EditorConfig) editorProcessKeypress() {
    ...
    switch b {
    ...
    default:
        e.editorInsertChar(byte(b))
    }
}

File: editor/row.go

func (e *EditorConfig) editorAppendRow(s string) {
    row := EditorRow{
        chars:  s,
        render: make([]byte, len(s)),
    }
    e.cx = 0
    e.editorUpdateRow(&row)
    e.rows = append(e.rows, row)
    e.numrows++
}

func (e *EditorConfig) editorRowInsertChar(row *EditorRow, at int, c byte) {
    row.render = make([]byte, len(row.chars)+1)
    row.chars = row.chars[:at] + string(c) + row.chars[at:]
    e.editorUpdateRow(row)
}

File: editor/operations.go

package editor

func (e *EditorConfig) editorInsertChar(c byte) {
    if e.cy >= len(e.rows) {
        e.editorAppendRow("")
    }
    e.editorRowInsertChar(&e.rows[e.cy], e.cx, c)
    e.cx++
}

Prevent inserting special characters

Now that we can insert characters, if we try to insert Backspace or Enter the editor does not understand them and we want to disable them for now

Backspace doesn't have a backslash-escape representation like (\r, \n, etc) but we know it is represented by the byte 127
Enter key is represented by the \r escape sequence
For the time being we will not be doing anything when the user press the Esc key, but we just want to disable it so no side effects occur if the user press it. Also by the way we've wrote the editorReadKey method, we will disable any function keys being pressed

File: utils/constants.go

const (
    ESC   = 0x1b
    ENTER = '\r'
    ...
)

const (
    BACKSPACE  = 127
    ARROW_LEFT = iota + 1000
    ...
)

File: utils/input.go

func (e *EditorConfig) editorProcessKeypress() {
    b, err := e.editorReadKey()
    if err != nil {
        utils.SafeExit(e.restoreFunc, err)
    }

    switch b {
    case utils.ENTER:
        slog.Info("ENTER")
    ...
    case utils.DEL_KEY, utils.BACKSPACE:
        slog.Info("DEL_KEY")
    ...
    case utils.ESC:
        // for now we will ignore when the user press the escape key
        break
    ...
}

Save to disk

Now that we can make changes to our files, it is time to be able to save them to disk

File: editor/editor.go

func (e *EditorConfig) EditorLoop() {
    ...
    e.editorSetStatusMessage("HELP: Ctrl-S = save | Ctrl-Q = quit")
    ...
}

File: editor/input.go

func (e *EditorConfig) editorProcessKeypress() {
    ...
    switch b {
    ...
    case utils.CtrlKey('s'):
        e.editorSave()
    ...
    }
}

File: editor/file.go

func (e *EditorConfig) editorSave() {
    data := make([]byte, 0)
    for _, row := range e.rows {
        data = append(data, row.chars...)
        data = append(data, '\r', '\n')
    }
    err := os.WriteFile(e.filename, data, 0644)
    if err != nil {
        slog.Error("editorSave, error saving file", "error", err)
        e.editorSetStatusMessage(fmt.Sprintf("Error saving file: %v", err))
        return
    }

    e.editorSetStatusMessage("File saved")
}

Note: if an error occurs while saving the file, we will not exit the application, we will show the error to the user and log it

Dirty flag

We want to keep track if the file we are showing the user differs from the one saved, so we can alert them if for example they want to quit without saving the file

File: editor/editor.go

type EditorConfig struct {
    ...
    isDirty       bool
}

func NewEditor(f func()) *EditorConfig {
    ...
    return &EditorConfig{
        ...
        isDirty:       false,
    }
}

File: editor/output.go

func (e *EditorConfig) editorDrawStatusBar(abuf *ab.AppendBuffer) {
    status := e.filename
    if status == "" {
        status = "[No Name]"
    }

    if e.isDirty {
        status += " (modified)"
    }
    ...
}

File: editor/row.go

func (e *EditorConfig) editorAppendRow(s string) {
    ...
    e.isDirty = true
}

func (e *EditorConfig) editorRowInsertChar(row *EditorRow, at int, c byte) {
    ...
    e.isDirty = true
}

File: editor/file.go

func (e *EditorConfig) editorOpen(filename string) {
    ...
    e.isDirty = false
}

func (e *EditorConfig) editorSave() {
    ...
    e.isDirty = false
}

Quit confirmation

Now that we control the isDirty flag, we will want to let the user know that they are trying to quit without saving the file

File: utils/constants.go

const (
    ...
    KILO_QUIT_TIMES = 3
)

File: editor/input.go

var quit_times = utils.KILO_QUIT_TIMES

func (e *EditorConfig) editorProcessKeypress() {
    ...
    switch b {
    ...
    case utils.CtrlKey('q'):
        if e.isDirty && quit_times > 0 {
            e.editorSetStatusMessage(fmt.Sprintf("WARNING! File has unsaved changes. Ctrl-Q %d more times to quit", quit_times))
            quit_times--
            return
        }
        utils.SafeExit(e.restoreFunc, nil)
    ...
    }

    quit_times = utils.KILO_QUIT_TIMES
}

Simple backspacing

Lets implement the Backspace and Delete keys

File: editor/input.go

func (e *EditorConfig) editorProcessKeypress() {
    ...
    switch b {
    ...
    case utils.DEL_KEY, utils.BACKSPACE:
        if b == utils.DEL_KEY {
            e.editorMoveCursor(utils.ARROW_RIGHT)
        }
        e.editorDeleteChar()
    ...
}

File: editor/operations.go

func (e *EditorConfig) editorDeleteChar() {
    if e.cy >= len(e.rows) {
        return
    }
    e.editorRowDeleteChar(&e.rows[e.cy], e.cx)
    if e.cx > 0 {
        e.cx--
    }
}

File: editor/row.go

func (e *EditorConfig) editorRowDeleteChar(row *EditorRow, at int) {
    if at < 0 || at >= len(row.chars) {
        return
    }
    row.render = make([]byte, len(row.chars)-1)
    row.chars = row.chars[:at] + row.chars[at+1:]
    e.editorUpdateRow(row)
    e.isDirty = true
}

Backspacing at the start of a line

Currently, editorDelChar doesn't do anything when the cursor is at the beginning of a line. When the user backspaces at the beginning of a line, we want to append the contents of that line to the previous line, and then delete the current line

File: editor/row.go

func (e *EditorConfig) editorDelRow(at int) {
    if at < 0 || at >= len(e.rows) {
        return
    }
    e.rows = append(e.rows[:at], e.rows[at+1:]...)
    e.numrows--
    e.isDirty = true
}

func (e *EditorConfig) editorRowAppendString(row *EditorRow, s string) {
    row.chars += s
    row.render = make([]byte, len(row.chars))
    e.editorUpdateRow(row)
    e.isDirty = true
}

File: editor/operations.go

func (e *EditorConfig) editorDeleteChar() {
    if e.cy >= len(e.rows) {
        return
    }
    if e.cx == 0 && e.cy == 0 {
        return
    }

    if e.cx > 0 {
        e.editorRowDeleteChar(&e.rows[e.cy], e.cx)
        e.cx--
    } else {
        e.cx = len(e.rows[e.cy-1].chars)
        e.editorRowAppendString(&e.rows[e.cy-1], e.rows[e.cy].chars)
        e.editorDelRow(e.cy)
        e.cy--
    }
}

The `Enter` key

The last keyboard input operation we will be going through is the implementation of the Enter key, which allows the user to insert new lines into the text, or split a line into two lines.

File: editor/row.go

func (e *EditorConfig) editorInsertRow(at int, s string) {
    e.rows = append(e.rows[:at], append([]EditorRow{{chars: s}}, e.rows[at:]...)...)
    e.numrows++
    e.isDirty = true
}

File: editor/operations.go

func (e *EditorConfig) editorInsertChar(c byte) {
    if e.cy == len(e.rows) {
        e.editorInsertRow(e.numrows, "")
    }
    ...
}

func (e *EditorConfig) editorInsertNewline() {
    if e.cy == len(e.rows) {
        e.editorInsertRow(e.numrows, "")
    } else {
        row := &e.rows[e.cy]
        e.editorInsertRow(e.cy+1, row.chars[e.cx:])
        row.chars = row.chars[:e.cx]
        row.render = make([]byte, len(row.chars))
        e.editorUpdateRow(row)

        row = &e.rows[e.cy+1]
        row.render = make([]byte, len(row.chars))
        e.editorUpdateRow(row)
    }
    e.cy++
    e.cx = 0
}

File: editor/input.go

func (e *EditorConfig) editorProcessKeypress() {
    ...
    switch b {
    case utils.ENTER:
        e.editorInsertNewline()
    ...
    }
    ...
}

Prompting the user

We want know to have the ability to prompt the user for input, so when they want to create a new file we can ask them for its name

File: utils/constants.go

const (
    ...
    KILO_DEFAULT_STATUS_MESSAGE = "HELP: Ctrl-S = save | Ctrl-Q = quit"
)

File: utils/ctrl.go

func IsCtrlKey(key int) bool {
    return key <= 0x1f || key == BACKSPACE
}

File: editor/editor.go

func (e *EditorConfig) EditorLoop() {
    ...
    e.editorSetStatusMessage(utils.KILO_DEFAULT_STATUS_MESSAGE)
    ...
}

File: editor/input.go

func (e *EditorConfig) editorProcessKeypress() {
    ...
    switch b {
    ...
    case utils.CtrlKey('c'):
        term := e.editorPrompt(": ")
        slog.Info("editorProcessKeypress, search term", "term", term)
    ...
    }
    ...
}

func (e *EditorConfig) editorPrompt(prompt string) string {
    var buf string
    for {
        e.editorSetStatusMessage(prompt + buf)
        e.editorRefreshScreen()

        b, err := e.editorReadKey()
        if err != nil {
            utils.SafeExit(e.restoreFunc, err)
        }

        switch b {
        case utils.BACKSPACE, utils.DEL_KEY:
            if len(buf) > 0 {
                buf = buf[:len(buf)-1]
            }
        case utils.ESC:
            slog.Info("editorPrompt, ESC")
            e.editorSetStatusMessage(utils.KILO_DEFAULT_STATUS_MESSAGE)
            return ""
        case utils.ENTER:
            e.editorSetStatusMessage(utils.KILO_DEFAULT_STATUS_MESSAGE)
            return buf
        default:
            if !utils.IsCtrlKey(b) || b < 128 {
                buf += string(rune(b))
            }
        }
    }
}

Note: We've added the Ctrl-C key map to test the prompt

Save as

Now that we can prompt things to the user, let's implement the Save as functionality, and it will only work at the moment when we run our editor without arguments

File: editor/file.go

func (e *EditorConfig) editorSave() {
    if e.filename == "" {
        e.filename = e.editorPrompt("Save as: ")
        if e.filename == "" {
            e.editorSetStatusMessage("Save aborted")
            return
        }
    }
    ...
}

Create a Text Editor in Go - Status Bar

Andres Court — Fri, 14 Nov 2025 02:19:53 +0000

You can access the code in this chapter in the Kilo-Go Github repository, in the statusbar branch.

Currently your file structure should look something like this:

Scrolling with `Page Up` and `Page Down`

Now that we have scrolling, let's make the Page Up and Page Down scroll an entire page

File: editor/input.go

func (e *EditorConfig) editorProcessKeypress() {
    ...
    switch b {
    ...
    case utils.PAGE_DOWN:
        e.cy = min(e.rowoffset+e.screenrows+1, e.numrows)
        times := e.screenrows
        for range times {
            e.editorMoveCursor(utils.ARROW_DOWN)
        }
    case utils.PAGE_UP:
        e.cy = e.rowoffset
        times := e.screenrows
        for range times {
            e.editorMoveCursor(utils.ARROW_UP)
        }
    ...
}

Move to the end of the line with `End`

Now let's have the End key to move the cursor to the end of the current line, not the end of the screen.

File: editor/input.go

func (e *EditorConfig) editorProcessKeypress() {
    ...
    switch b {
    ...
    case utils.END_KEY:
        if e.cy < e.numrows {
            e.cx = len(e.rows[e.cy].chars)
        }
    }
}

Make space for the status bar

The last thing we will add before editing text, is a status bar. This will display useful information such as the file name, the cursor position, and other things that we will find useful as we continue working on the editor. However, first thing is we need to have some space in the screen to display the status bar.

File: editor/editor.go

func NewEditor(f func()) *EditorConfig {
    rows, cols, err := utils.GetWindowSize()
    ...
    return &EditorConfig{
        ...
        screenrows:  rows - 1,
        ...
    }
}

File: editor/output.go

func (e *EditorConfig) editorDrawRows(abuf *ab.AppendBuffer) {
    for y := range e.screenrows {
        filerow := y + e.rowoffset
        ...
        fmt.Fprintf(abuf, "%c[K", utils.ESC) // We moved this line from the top to the bottom of the for loop
        fmt.Fprintf(abuf, "\r\n")
    }
}

Display the status bar

To display the status bar, lets make it have inverted color as the rest of the screen. The m command causes the text printed after it to be printed with various possible attributes including bold 1, underscore 4, blink 5, and inverted colors 7. For example, you could specify all of these attributes using the command <Esc>[1;4;5;7m. An argument of 0 clears all attributes, and is the default argument, so we use <Esc>[m to go back to normal text formatting.

File: editor/output.go

func (e *EditorConfig) editorRefreshScreen() {
    ...
    e.editorDrawRows(abuf)
    e.editorDrawStatusBar(abuf)
    ...
}

func (e *EditorConfig) editorDrawStatusBar(abuf *ab.AppendBuffer) {
    fmt.Fprintf(abuf, "%c[7m", utils.ESC)

    for range e.screencols {
        fmt.Fprintf(abuf, " ")
    }

    fmt.Fprintf(abuf, "%c[m", utils.ESC)
}

Display the file name

So lets begin displaying some useful information to the status line, the first thing we will show is the name of the file we are currently editing, and if we haven't opened any file we will display [No name]

File: editor/editor.go

type EditorConfig struct {
    ...
    filename    string
    ...
}

func NewEditor(f func()) *EditorConfig {
    ...
    return &EditorConfig{
        ...
        filename:    "",
        ...
    }
}

File: editor/file.go

func (e *EditorConfig) editorOpen(filename string) {
    ...
    e.filename = filename
    ...
}

File: editor/output.go

func (e *EditorConfig) editorDrawStatusBar(abuf *ab.AppendBuffer) {
    status := e.filename
    if status == "" {
        status = "[No Name]"
    }

    fmt.Fprintf(abuf, "%c[7m", utils.ESC)

    fmt.Fprintf(abuf, " %s", status)
    for range e.screencols - (len(status) + 1) {
        fmt.Fprintf(abuf, " ")
    }

    fmt.Fprintf(abuf, "%c[m", utils.ESC)
}

Display the cursor position

Let's display at the right side of the status bar the cursor's position information

File: editor/output.go

func (e *EditorConfig) editorDrawStatusBar(abuf *ab.AppendBuffer) {
    ...
    width := e.screencols - len(status) - 1

    rstatus := fmt.Sprintf("column: %d row: %d/%d ", e.rx+1, e.cy+1, e.numrows)
    ...
    for k := range width {
        if k+len(rstatus) == width {
            fmt.Fprintf(abuf, "%s", rstatus)
            break
        }
        fmt.Fprintf(abuf, " ")
    }
    ...
}

Status message

We will now add a place where we can give user some information below the status bar

File: editor/editor.go

type EditorConfig struct {
    ...
    statusMessage string
    ...
}

func NewEditor(f func()) *EditorConfig {
    rows, cols, err := utils.GetWindowSize()
    if err != nil {
        utils.SafeExit(f, err)
    }

    return &EditorConfig{
        ...
        screenrows:    rows - 2,
        ...
        statusMessage: "",
        ...
    }
}

func (e *EditorConfig) EditorLoop() {
    ...
    e.editorSetStatusMessage("HELP: Ctrl-Q = quit")
    for {
        ...
    }
}

File: editor/output.go

func (e *EditorConfig) editorRefreshScreen() {
    ...
    e.editorDrawRows(abuf)
    e.editorDrawStatusBar(abuf)
    e.editorDrawMessageBar(abuf)
    ...
}

func (e *EditorConfig) editorDrawStatusBar(abuf *ab.AppendBuffer) {
    ...
    fmt.Fprintf(abuf, "%c[m", utils.ESC)
    fmt.Fprintf(abuf, "\r\n")
}

func (e *EditorConfig) editorSetStatusMessage(message string) {
    e.statusMessage = message
}

func (e *EditorConfig) editorDrawMessageBar(abuf *ab.AppendBuffer) {
    fmt.Fprintf(abuf, "%c[K", utils.ESC)
    fmt.Fprintf(abuf, " %s", e.statusMessage)
}

What we've achieved

After finishing all of the steps until now, the editor, should look something like this:

Create a Text Editor in Go - Text Viewer

Andres Court — Thu, 13 Nov 2025 01:15:50 +0000

You can access the code of this chapter in the Kilo-Go github repository in the movingaround branch

Currently your file structure should look something like this:

A line viewer

First we want to be able to view a single line without reading it from a file, we will do that later

File: editor/editor.go

type EditorRow struct {
    chars string
}

type EditorConfig struct {
    restoreFunc func()
    reader      *bufio.Reader
    rows, cols  int
    cx, cy      int
    numrows     int
    row         EditorRow
}

func NewEditor(f func()) *EditorConfig {
    ...
    return &EditorConfig{
        restoreFunc: f,
        reader:      bufio.NewReader(os.Stdin),
        rows:        rows,
        cols:        cols,
        cx:          0,
        cy:          0,
        numrows:     0,
    }
}

func (e *EditorConfig) EditorLoop() {
    defer utils.SafeExit(e.restoreFunc, nil)
    e.editorOpen()
    ...
}

File: editor/file.go

package editor

func (e *EditorConfig) editorOpen() {
    line := "Hello, world!"
    e.row.chars = line
    e.numrows = 1
}

File: editor/output.go

func (e *EditorConfig) editorDrawRows(abuf *ab.AppendBuffer) {
    for y := range e.rows {
        if y >= e.numrows {
            if y == e.rows/3 {
                ...
            }
        } else {
            fmt.Fprintf(abuf, "%s", e.row.chars)
        }
        ...
    }
}

Reading command line arguments

If we pass a file name through the arguments, we want the application to be able to read its name so we can process it later, if we've done everything right, then we will have in our logs the name of the file we want to view

File: editor/editor.go

func (e *EditorConfig) EditorLoop() {
    defer utils.SafeExit(e.restoreFunc, nil)

    if len(os.Args) > 1 {
        slog.Info("Opening file", "file", os.Args[1])
        e.editorOpen()
    }
    ...
}

Go provide us with the os.Args variable which holds an array with all the arguments passed in the command line being:

Argument 0: the name of the program that was executed

Argument 1: in our case the name of the file we want to view

Opening the file

Now lets print the first line of the file we passed as an argument

File: editor/editor.go

func (e *EditorConfig) EditorLoop() {
    ...
    if len(os.Args) > 1 {
        e.editorOpen(os.Args[1])
    }
    ...
}

File: editor/file.go

func (e *EditorConfig) editorOpen(filename string) {
    file, err := os.Open(filename)
    if err != nil {
        fmt.Fprintf(os.Stderr, "editorOpen, error opening file: %v\r\n", err)
        utils.SafeExit(e.restoreFunc, err)
        os.Exit(1)
    }
    defer file.Close()

    scanner := bufio.NewScanner(file)

    scanner.Scan()
    e.row.chars = scanner.Text()
    e.numrows = 1

    if err := scanner.Err(); err != nil {
        fmt.Fprintf(os.Stderr, "editorOpen, error scanning file: %v\r\n", err)
        utils.SafeExit(e.restoreFunc, err)
        os.Exit(1)
    }
}

Hide the welcome message

Now that we are reading from file, the welcome message may come in the way once we reach there with the text, so we need to hide it when opening a file

File: editor/output.go

func (e *EditorConfig) editorDrawRows(abuf *ab.AppendBuffer) {
    for y := range e.rows {
        if y >= e.numrows {
            if e.numrows == 0 && y == e.rows/3 {
            ...
}

Refactor rename `rows` and `cols`

For better readability we will rename the fields rows and cols to the more meaningful name screenrows and screencols

File: editor/editor.go

type EditorConfig struct {
    ...
    screenrows  int
    screencols  int
    ...
}

func NewEditor(f func()) *EditorConfig {
    ...
    return &EditorConfig{
        ...
        screenrows:  rows,
        screencols:  cols,
        ...
    }
}

File: editor/input.go

func (e *EditorConfig) editorProcessKeypress() {
    ...
    switch b {
    ...
    case utils.ARROW_DOWN, utils.ARROW_LEFT, utils.ARROW_RIGHT, utils.ARROW_UP:
        e.editorMoveCursor(b)
    case utils.PAGE_DOWN, utils.PAGE_UP:
        times := e.screenrows
    ...
    case utils.END_KEY:
        e.cx = e.screencols - 1
    }
}

func (e *EditorConfig) editorMoveCursor(key int) {
    switch key {
    ...
    case utils.ARROW_DOWN:
        if e.cy != e.screenrows-1 {
            e.cy++
        }
    ...
    case utils.ARROW_RIGHT:
        if e.cx != e.screencols-1 {
            e.cx++
        }
    }
}

File: editor/output.go

func (e *EditorConfig) editorDrawRows(abuf *ab.AppendBuffer) {
    for y := range e.screenrows {
        if y >= e.numrows {
            if e.numrows == 0 && y == e.screenrows/3 {
                ...
                welcomeLen := min(len(welcomeMessage), e.screencols)

                padding := (e.screencols - welcomeLen) / 2
                ...
        if y < e.screenrows-1 {
            fmt.Fprintf(abuf, "\r\n")
        }
    }
}

Multiple lines

We are finally ready to read multiple lines from the file, first we have to have a place holder to store all the lines in, so lets change the row field in our struct to be an array of rows

File: editor/editor.go

type EditorConfig struct {
    ...
    rows        []EditorRow
}

func NewEditor(f func()) *EditorConfig {
    ...
    return &EditorConfig{
        ...
        rows:        make([]EditorRow, 0),
    }
}

File: editor/file.go

func (e *EditorConfig) editorOpen(filename string) {
    ...
    for scanner.Scan() {
        row := EditorRow{chars: scanner.Text()}
        e.rows = append(e.rows, row)
        e.numrows++
    }
    ...
}

File: editor/output.go

func (e *EditorConfig) editorDrawRows(abuf *ab.AppendBuffer) {
    for y := range e.screenrows {
        if y >= e.numrows { 
            ...
        } else {
            fmt.Fprintf(abuf, "%s", e.rows[y].chars)
        }
        ...
    }
}

Vertical Scrolling

What happens if our text goes past the window limits, so lets add the ability to scroll vertically

File: editor/editor.go

type EditorConfig struct {
    ...
    rowoffset   int
    ...
}

func NewEditor(f func()) *EditorConfig {
    ...
    return &EditorConfig{
        ...
        rowoffset:   0,
        ...
    }
}

File: editor/input.go

func (e *EditorConfig) editorMoveCursor(key int) {
    switch key {
    case utils.ARROW_LEFT:
        if e.cx > 0 {
            e.cx--
        }
    case utils.ARROW_DOWN:
        if e.cy < e.numrows {
            e.cy++
        }
    ...
    }
}

File: editor/output.go

func (e *EditorConfig) editorRefreshScreen() {
    e.editorScroll()
    ...
    fmt.Fprintf(abuf, "%c[%d;%dH", utils.ESC, (e.cy-e.rowoffset)+1, e.cx+1)
    ...
}

func (e *EditorConfig) editorDrawRows(abuf *ab.AppendBuffer) {
    for y := range e.screenrows {
        filerow := y + e.rowoffset
        fmt.Fprintf(abuf, "%c[K", utils.ESC)
        if filerow >= e.numrows {
            ...
        } else {
            fmt.Fprintf(abuf, "%s", e.rows[filerow].chars)
        }
        ...
    }
}

func (e *EditorConfig) editorScroll() {
    if e.cy < e.rowoffset {
        e.rowoffset = e.cy
    }
    if e.cy >= e.rowoffset+e.screenrows {
        e.rowoffset = e.cy - e.screenrows + 1
    }
}

Horizontal scrolling

We will implement horizontal scrolling in a similar way as we did the vertical scrolling

File: editor/editor.go

type EditorConfig struct {
    ...
    colloffset  int
    ...
}

func NewEditor(f func()) *EditorConfig {
    ...
    return &EditorConfig{
        ...
        colloffset:  0,
        ...
    }
}

File: editor/input.go

func (e *EditorConfig) editorMoveCursor(key int) {
    switch key {
    ...
    case utils.ARROW_RIGHT:
        e.cx++
    }
}

File: editor/output.go

func (e *EditorConfig) editorRefreshScreen() {
    ...
    fmt.Fprintf(abuf, "%c[%d;%dH", utils.ESC, (e.cy-e.rowoffset)+1, (e.cx-e.colloffset)+1)
    ...
}

func (e *EditorConfig) editorDrawRows(abuf *ab.AppendBuffer) {
    for y := range e.screenrows {
        ...
        if filerow >= e.numrows {
            ...
        } else {
            chars := e.rows[filerow].chars
            if len(chars) < e.colloffset {
                chars = ""
            } else {
                chars = chars[e.colloffset:]
            }
            if len(chars) > e.screencols {
                chars = chars[e.colloffset:e.screencols]
            }

            fmt.Fprintf(abuf, "%s", chars)
        ...
    }
}

func (e *EditorConfig) editorScroll() {
    ...
    if e.cx < e.colloffset {
        e.colloffset = e.cx
    }
    if e.cx >= e.colloffset+e.screencols {
        e.colloffset = e.cx - e.screencols + 1
    }
}

Limit scrolling to the right

Now that we are able to move around the file, we should not be able to move past the last character in a line, making it invalid position. Lets start by not allowing the user to scroll past the end of the current line

File: editor/input.go

func (e *EditorConfig) editorMoveCursor(key int) {
    var row *EditorRow = nil
    if e.cy < e.numrows {
        row = &e.rows[e.cy]
    }

    switch key {
    ...
    case utils.ARROW_RIGHT:
        if row != nil && e.cx < len(row.chars) {
            e.cx++
        }
    }
}

Note: If in your file have some Tabs our editor still recognizes them as one character but displays them like there are several spaces, we will fix that in a later step

Snap cursor to end of line

If you go to the end of a line and move to another which is shorter, the cursor will still be in an invalid position, lets fix that

File: editor/input.go

func (e *EditorConfig) editorMoveCursor(key int) {
    ...
    switch key {
    ...
    }

    row = nil
    if e.cy < e.numrows {
        row = &e.rows[e.cy]
    }

    if row != nil && e.cx > len(row.chars) {
        e.cx = len(row.chars)
    }
}

Moving left at the start of a line

Let's allow the user to press Left Arrow at the beginning of the line to move to the end of the previous line

File: editor/input.go

func (e *EditorConfig) editorMoveCursor(key int) {
    ...
    switch key {
    case utils.ARROW_LEFT:
        if e.cx != 0 {
            e.cx--
        } else if e.cy > 0 {
            e.cy--
            e.cx = len(e.rows[e.cy].chars)
        }
    ...
    }
    ...
}

Moving right at the end of a line

Similarly, lets allow the user to press Right Arrow at the end of a line to go to the beginning of the next line.

File: editor/input.go

func (e *EditorConfig) editorMoveCursor(key int) {
    ...
    switch key {
    ...
    case utils.ARROW_RIGHT:
        if row != nil && e.cx < len(row.chars) {
            e.cx++
        } else if row != nil && e.cx == len(row.chars) {
            e.cy++
            e.cx = 0
        }
    }
    ...
}

Rendering tabs

If you try opening a file that uses a tab character \t, you'll notice that it renders about 8 characters wide, but when you move the cursor it only moves on character per tab. The rendering space is related to the terminal being used and it settings. We want to know the length of each tab, and we also want to control how to render tabs. First we want to create that rendering space

File: editor/editor.go

type EditorRow struct {
    chars  string
    render []byte
}

File: editor/file.go

func (e *EditorConfig) editorOpen(filename string) {
    ...
    for scanner.Scan() {
        e.editorAppendRow(scanner.Text())
    }
    ...
}

File: editor/row.go

package editor

func (e *EditorConfig) editorAppendRow(s string) {
    row := EditorRow{
        chars:  s,
        render: make([]byte, 0),
    }
    e.editorUpdateRow(&row)
    e.rows = append(e.rows, row)
    e.numrows++
}

func (e *EditorConfig) editorUpdateRow(row *EditorRow) {
    for j := 0; j < len(row.chars); j++ {
        row.render = append(row.render, row.chars[j])
    }
}

File: editor/output.go

func (e *EditorConfig) editorDrawRows(abuf *ab.AppendBuffer) {
    for y := range e.screenrows {
        ...
        if filerow >= e.numrows {
            ...
        } else {
            chars := e.rows[filerow].render
            if len(chars) < e.colloffset {
                chars = make([]byte, 0)
            } else {
                chars = chars[e.colloffset:]
            }
            if len(chars) > e.screencols {
                chars = chars[e.colloffset:e.screencols]
            }

            fmt.Fprintf(abuf, "%s", chars)
        }
        ...
    }
}

Read the `\t` character

Let's start rendering the \t character by replacing it with spaces in our render field

File: utils/constants.go

const (
    ...
    KILO_TAB_STOP = 8
)

File: editor/row.go

func (e *EditorConfig) editorUpdateRow(row *EditorRow) {
    for j := 0; j < len(row.chars); j++ {
        if row.chars[j] == '\t' {
            for range utils.KILO_TAB_STOP {
                row.render = append(row.render, ' ')
            }
        } else {
            row.render = append(row.render, row.chars[j])
        }
    }
}

Tabs and the cursor

Currently we display the \t character as a defined number of spaces in our KILO_TAB_STOP constant, but when moving around it still reads just one character per \t, so lets fix it

File: editor/editor.go

type EditorConfig struct {
    ...
    rx          int
    ...
}

func NewEditor(f func()) *EditorConfig {
    ...
    return &EditorConfig{
        ...
        rx:          0,
        ...
    }
}

File: editor/row.go

func editorRowCxToRx(row *EditorRow, cx int) int {
    rx := 0
    for j := range cx {
        if row.chars[j] == '\t' {
            rx += utils.KILO_TAB_STOP
        } else {
            rx++
        }
    }
    return rx
}

File: editor/output.go

func (e *EditorConfig) editorRefreshScreen() {
    ...
    fmt.Fprintf(abuf, "%c[%d;%dH", utils.ESC, (e.cy-e.rowoffset)+1, (e.rx-e.colloffset)+1)
    ...
}

func (e *EditorConfig) editorScroll() {
    e.rx = 0
    if e.cy < e.numrows {
        e.rx = editorRowCxToRx(&e.rows[e.cy], e.cx)
    }
    ...
    if e.rx < e.colloffset {
        e.colloffset = e.rx
    }
    if e.rx >= e.colloffset+e.screencols {
        e.colloffset = e.rx - e.screencols + 1
    }
}

Create a Text Editor in Go - Moving the Cursor

Andres Court — Mon, 10 Nov 2025 22:46:18 +0000

You can access the code of this chapter in the Kilo-Go github repository in the movingaround branch

Currently your file structure should look something like this:

Cursor state

First we need a way to track the cursor position

File: editor/editor.go

type EditorConfig struct {
    ...
    cx, cy      int
}

func NewEditor(f func()) *EditorConfig {
    ...
    return &EditorConfig{
        ...
        cx:          0,
        cy:          0,
    }
}

File: editor/output.go

func (e *EditorConfig) editorRefreshScreen() {
    ...
    e.editorDrawRows(abuf)
    fmt.Fprintf(abuf, "%c[%d;%dH", utils.ESC, e.cy + 1, e.cx+1)
    fmt.Fprintf(abuf, "%c[?25h", utils.ESC)
    ...
}

func (e *EditorConfig) editorDrawRows(abuf *ab.AppendBuffer) {
    for y := range e.rows {
        if y == e.rows/3 {
            ...
            welcomeLen := min(len(welcomeMessage), e.cols)
            ...
        }
    }
}

Cursor movement

Now that we've tracked the cursor position, we can add the logic to move the cursor with vim-like keys so we will be using h, j, k and l

File: editor/input.go

func (e *EditorConfig) editorProcessKeypress() {
    ...
    switch b {
    case utils.CtrlKey('q'):
        utils.SafeExit(e.restoreFunc, nil)
    case 'h', 'j', 'k', 'l':
        e.editorMoveCursor(b)
    }
}

func (e *EditorConfig) editorMoveCursor(key byte) {
    switch key {
    case 'h':
        e.cx--
    case 'j':
        e.cy++
    case 'k':
        e.cy--
    case 'l':
        e.cx++
    }
}

Reading the arrow keys

Lets read the arrow keys next, each one is represented by 3 bytes:

Up Arrow is represented by <Esc> [ A
Down Arrow is represented by <Esc> [ B
Right Arrow is represented by <Esc> [ C
Left Arrow is represented by <Esc> [ D

So with that in mind, lets read them

File: editor/terminal.go

import (
    "github.com/alcb1310/kilo-go/utils"
)

func (e *EditorConfig) editorReadKey() (byte, error) {
    b, err := e.reader.ReadByte()

    if b == utils.ESC {
        seq := make([]byte, 2)

        seq[0], err = e.reader.ReadByte()
        if err != nil {
            return utils.ESC, nil
        }
        seq[1], err = e.reader.ReadByte()
        if err != nil {
            return utils.ESC, nil
        }

        if seq[0] == '[' {
            switch seq[1] {
            case 'A':
                return 'k', nil
            case 'B':
                return 'j', nil
            case 'C':
                return 'l', nil
            case 'D':
                return 'h', nil
            }
        }

        return utils.ESC, nil
    }

    return b, err
}

Refactor: improve readability

Now that we have the arrow keys working, lets improve the readability by creating constants for it

File: utils/constants.go

const (
    ARROW_UP    = 'k'
    ARROW_DOWN  = 'j'
    ARROW_LEFT  = 'h'
    ARROW_RIGHT = 'l'
)

File: editor/input.go

func (e *EditorConfig) editorProcessKeypress() {
    ...
    switch b {
    case utils.CtrlKey('q'):
        utils.SafeExit(e.restoreFunc, nil)
    case utils.ARROW_DOWN, utils.ARROW_LEFT, utils.ARROW_RIGHT, utils.ARROW_UP:
        e.editorMoveCursor(b)
    }
}

func (e *EditorConfig) editorMoveCursor(key byte) {
    switch key {
    case utils.ARROW_LEFT:
        e.cx--
    case utils.ARROW_DOWN:
        e.cy++
    case utils.ARROW_UP:
        e.cy--
    case utils.ARROW_RIGHT:
        e.cx++
    }
}

File: editor/terminal.go

func (e *EditorConfig) editorReadKey() (byte, error) {
        ...
        if seq[0] == '[' {
            switch seq[1] {
            case 'A':
                return utils.ARROW_UP, nil
            case 'B':
                return utils.ARROW_DOWN, nil
            case 'C':
                return utils.ARROW_RIGHT, nil
            case 'D':
                return utils.ARROW_LEFT, nil
            }
        }
        ...
}

Refactor: only use arrows to move

Now that we've added constants to the arrow keys we can give them a value outside of the byte range and start using them as an int. However doing so, we will need to change several files in order to return int instead of byte

File: utils/constant.go

const (
    ARROW_UP = iota + 1000
    ARROW_DOWN
    ARROW_LEFT
    ARROW_RIGHT
)

File: utils/ctrl.go

func CtrlKey(key byte) int {
    return int(key & 0x1f)
}

File editor/input.go

func (e *EditorConfig) editorMoveCursor(key int) {
    ...
}

File editor/terminal.go

func (e *EditorConfig) editorReadKey() (int, error) {
    ...
    return int(b), err
}

Note: We mostly needed to change the function signature for it to work

Prevent moving the cursor off screen

Currently, we can have the cx and cy values to go into the negatives or go past the right and bottom edges of the screen, so lets prevent that

File: editor/input.go

func (e *EditorConfig) editorMoveCursor(key int) {
    switch key {
    case utils.ARROW_LEFT:
        if e.cx != 0 {
            e.cx--
        }
    case utils.ARROW_DOWN:
        if e.cy != e.rows-1 {
            e.cy++
        }
    case utils.ARROW_UP:
        if e.cy != 0 {
            e.cy--
        }
    case utils.ARROW_RIGHT:
        if e.cx != e.cols-1 {
            e.cx++
        }
    }
}

The `Page Up` and `Page Down` keys

To complete our movements, we need to detect a few more special keypresses that use escape sequences, like the arrow keys did. We'll start with the Page Up which is sent as <Esc> [ 5 ~ and Page Down which is sent as <Esc> [ 6 ~

File utils/constants.go

const (
    ARROW_UP = iota + 1000
    ARROW_DOWN
    ARROW_LEFT
    ARROW_RIGHT
    PAGE_UP
    PAGE_DOWN
)

File: editor/terminal.go

func (e *EditorConfig) editorProcessKeypress() {
    ...
    case utils.PAGE_DOWN, utils.PAGE_UP:
        times := e.rows
        for range times {
            if b == utils.PAGE_DOWN {
                e.editorMoveCursor(utils.ARROW_DOWN)
            } else {
                e.editorMoveCursor(utils.ARROW_UP)
            }
        }
    }
}

File: editor/terminal.go

func (e *EditorConfig) editorReadKey() (int, error) {
    ...
    if b == utils.ESC {
        seq := make([]byte, 3)
        ...
        if seq[0] == '[' {
            if seq[1] >= '0' && seq[1] <= '9' {
                seq[2], err = e.reader.ReadByte()
                if err != nil {
                    return utils.ESC, nil
                }

                if seq[2] == '~' {
                    switch seq[1] {
                    case '5':
                        return utils.PAGE_UP, nil
                    case '6':
                        return utils.PAGE_DOWN, nil
                    }
                }
            } else {
                switch seq[1] {
                case 'A':
                    return utils.ARROW_UP, nil
                case 'B':
                    return utils.ARROW_DOWN, nil
                case 'C':
                    return utils.ARROW_RIGHT, nil
                case 'D':
                    return utils.ARROW_LEFT, nil
                }
            }
        }
    ...
}

The `Home` and `End` keys

Like the previous keys, these keys also send escape sequences. Unlike previous keys, there are many different escape sequences that could be sent by these keys.

The Home key could be sent as <Esc> [ 1 ~, <Esc> [ 7 ~, <Esc> [ H or <Esc> O H
The End key could be sent as <Esc> [ 4 ~, <Esc> [ 8 ~, <Esc> [ F or <Esc> O F

File: utils/constants.go

const (
    ARROW_UP = iota + 1000
    ARROW_DOWN
    ARROW_LEFT
    ARROW_RIGHT
    HOME_KEY
    END_KEY
    PAGE_UP
    PAGE_DOWN
)

File: editor/terminal.go

func (e *EditorConfig) editorReadKey() (int, error) {
        ...
        if seq[0] == '[' {
            if seq[1] >= '0' && seq[1] <= '9' {
                ...
                if seq[2] == '~' {
                    switch seq[1] {
                    case '1':
                        return utils.HOME_KEY, nil
                    case '4':
                        return utils.END_KEY, nil
                    case '5':
                        return utils.PAGE_UP, nil
                    case '6':
                        return utils.PAGE_DOWN, nil
                    case '7':
                        return utils.HOME_KEY, nil
                    case '8':
                        return utils.END_KEY, nil
                    }
                }
            } else {
                switch seq[1] {
                case 'A':
                    return utils.ARROW_UP, nil
                case 'B':
                    return utils.ARROW_DOWN, nil
                case 'C':
                    return utils.ARROW_RIGHT, nil
                case 'D':
                    return utils.ARROW_LEFT, nil
                case 'H':
                    return utils.HOME_KEY, nil
                case 'F':
                    return utils.END_KEY, nil
                }
            }
        } else if seq[0] == 'O' {
            switch seq[1] {
            case 'H':
                return utils.HOME_KEY, nil
            case 'F':
                return utils.END_KEY, nil
            }
        }
        ...
}

File: editor/input.go

func (e *EditorConfig) editorProcessKeypress() {
    ...
    switch b {
    ...
    case utils.HOME_KEY:
        e.cx = 0
    case utils.END_KEY:
        e.cx = e.cols - 1
    }
}

The `Delete` key

Lastly we will detect when the Delete key is pressed. It simply sends the escape sequence <Esc> [ 3 ~, so it will be easy to add it to our switch statement. For now we will just log when the key is pressed

File: utils/constants.go

const (
    ARROW_LEFT = iota + 1000
    ARROW_RIGHT
    ARROW_UP
    ARROW_DOWN
    DEL_KEY
    HOME_KEY
    END_KEY
    PAGE_UP
    PAGE_DOWN
)

File: editor/terminal.go

func (e *EditorConfig) editorReadKey() (int, error) {
    ...
    if b == utils.ESC {
        ...
        switch seq[0] {
        case '[':
            if seq[1] >= '0' && seq[1] <= '9' {
                ...
                if seq[2] == '~' {
                    switch seq[1] {
                    case '1':
                        return utils.HOME_KEY, nil
                    case '3':
                        return utils.DEL_KEY, nil
                    ...
                    }
                }
            ...
        case 'O':
            switch seq[1] {
            case 'H':
                return utils.HOME_KEY, nil
            case 'F':
                return utils.END_KEY, nil
            }
        }

    ...
}

File: editor/input.go

func (e *EditorConfig) editorProcessKeypress() {
    ...
    switch b {
    ...
    case utils.DEL_KEY:
        slog.Info("DEL_KEY")
    ...
}

Create a Text Editor With Go - Welcome Screen

Andres Court — Sun, 09 Nov 2025 13:10:07 +0000

You can access the code of this chapter in the Kilo-Go github repository in the welcomescreen branch

Currently your file structure should look something like this:

Refactor: rename the exit module to utils

Since we will be adding more features to the utils module, it only makes sense if we rename it from exit to utils

mv exit utils

File: utils/exit.go

package utils

import (
    "fmt"
    "os"
)

// SafeExit is a function that allows us to safely exit the program
//
// # It will call the provided function and exit with the provided error
// if no error is provided, it will exit with 0
//
// @param f - The function to call
// @param err - The error to exit with
func SafeExit(f func(), err error) {
    if f != nil {
        f()
    }

    if err != nil {
        fmt.Fprintf(os.Stderr, "Error: %s\r\n", err)
        os.Exit(1)
    }

    os.Exit(0)
}

File: linux/raw.go

func (r *UnixRawMode) EnableRawMode() (func(), error) {
    ...
    return func() {
        if err = unix.IoctlSetTermios(unix.Stdin, unix.TCSETS, &original); err != nil {
            utils.SafeExit(nil, fmt.Errorf("EnableRawMode: error restoring terminal flags: %w", err))
        }
    }, nil
}

File: main.go

func main() {
    defer utils.SafeExit(editorState.restoreFunc, nil)
    ...
    for {
        b, err := r.ReadByte()
        if err == io.EOF {
            break
        } else if err != nil {
            utils.SafeExit(editorState.restoreFunc, err)
        }
        ...
    }
}

Press `Ctrl-Q` to quit

At the moment, when we press q the program exits, lets change it to be Ctrl-Q.

We will need to first recognize if the key pressed corresponds to a control-key combo, so we will write a function in the utility module

File: utils/ctrl.go

package utils

func CtrlKey(key byte) byte {
    return key & 0x1f
}

File: main.go

func main() {
    ...
    for {
        ...
        if b == utils.CtrlKey('q') {
            break
        }
    }
}

Refactor keyboard input

First we want to make a new package editor, where we will be mostly working and manage our state there, and also we are going to refactor the read and process key press

File: editor/editor.go

package editor

import (
    "bufio"
    "os"

    "github.com/alcb1310/kilo-go/utils"
)

type EditorConfig struct {
    restoreFunc func()
    reader      *bufio.Reader
}

func NewEditor(f func()) *EditorConfig {
    return &EditorConfig{
        restoreFunc: f,
        reader:      bufio.NewReader(os.Stdin),
    }
}

func (e *EditorConfig) EditorLoop() {
    defer utils.SafeExit(e.restoreFunc, nil)

    for {
        e.editorProcessKeypress()
    }
}

File: editor/input.go

package editor

import "github.com/alcb1310/kilo-go/utils"

func (e *EditorConfig) editorProcessKeypress() {
    b, err := e.editorReadKey()
    if err != nil {
        utils.SafeExit(e.restoreFunc, err)
    }

    switch b {
    case utils.CtrlKey('q'):
        utils.SafeExit(e.restoreFunc, nil)
    }
}

File: editor/terminal.go

package editor

func (e *EditorConfig) editorReadKey() (byte, error) {
    b, err := e.reader.ReadByte()

    return b, err
}

File: main.go

package main

import (
    "fmt"
    "os"

    "github.com/alcb1310/kilo-go/editor"
    "github.com/alcb1310/kilo-go/linux"
)

var restoreFunc func()

func init() {
    var err error
    u := linux.NewUnixRawMode()
    restoreFunc, err = u.EnableRawMode()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error: %s\r\n", err)
        os.Exit(1)
    }
}

func main() {
    editor := editor.NewEditor(restoreFunc)
    editor.EditorLoop()
}

So now our main function is very simple, where we just enable raw mode and start the editor, so lets keep it this way

Clear the screen

First we want to clear the screen so we don't have anything in it so we can work on, we will be using the VT100 User Guide which is a series of key combos that interacts with the screen.

File: editor/output.go

package editor

import (
    "fmt"
    "os"

    "github.com/alcb1310/kilo-go/utils"
)

func (e *EditorConfig) editorRefreshScreen() {
    fmt.Fprintf(os.Stdout, "%c[2J", utils.ESC)
}

File: utils/constants.go

package utils

const (
    ESC = 0x1b
)

File: editor/editor.go

func (e *EditorConfig) EditorLoop() {
    defer utils.SafeExit(e.restoreFunc, nil)

    for {
        e.editorRefreshScreen()
        e.editorProcessKeypress()
    }
}

Now the problem is that the cursor is left wherever it was before we clear the screen

Reposition the cursor

We will be using the H command that manages the cursor position, it takes two arguments, the row and column we want to have the cursor at, if no arguments are passed, then it is assumed to be 1 so ESC[H is the same as ESC[1;1H, remember that rows and columns start at number 1 and not 0

File: editor/output.go

func (e *EditorConfig) editorRefreshScreen() {
    fmt.Fprintf(os.Stdout, "%c[2J", utils.ESC)
    fmt.Fprintf(os.Stdout, "%c[H", utils.ESC)
}

Clear the screen on exit

Lets use what we've achieved so far so when our program exits it will clear the screen. This way if an error occurs we will not have a bunch of garbage on the screen improving their experience, and also when on exit we will not show anything that was rendered.

File: utils/exit.go

func SafeExit(f func(), err error) {
    fmt.Fprintf(os.Stdout, "%c[2J", ESC)
    fmt.Fprintf(os.Stdout, "%c[H", ESC)
    ...
}

Tildes

Finally we are in a point where we will start drawing thing to the screen. First we will give it a Vim feel by drawing some tildes (~) at the left of the screen of every line that come after the end of the file being edited

File: editor/output.go

func (e *EditorConfig) editorRefreshScreen() {
    fmt.Fprintf(os.Stdout, "%c[2J", utils.ESC)
    fmt.Fprintf(os.Stdout, "%c[H", utils.ESC)

    e.editorDrawRows()

    fmt.Fprintf(os.Stdout, "%c[H", utils.ESC)
}

func (e *EditorConfig) editorDrawRows() {
    for range 24 {
        fmt.Fprintf(os.Stdout, "~\r\n")
    }
}

Window Size

At the moment we forced a total of 24 rows, but we want our editor to use all of the rows in your monitor, so we need to find the window size

File: utils/window.go

package utils

import (
    "fmt"
    "os"

    "golang.org/x/sys/unix"
)

func GetWindowSize() (rows int, cols int, err error) {
    ws, err := unix.IoctlGetWinsize(unix.Stdin, unix.TIOCGWINSZ)
    if err != nil {
        fmt.Fprintf(os.Stderr, "getWindowSize: Error getting window size: %v\r\n", err)
        return
    }

    rows = int(ws.Row)
    cols = int(ws.Col)

    return
}

File: editor/editor.go

type EditorConfig struct {
    restoreFunc func()
    reader      *bufio.Reader
    rows, cols  int
}

func NewEditor(f func()) *EditorConfig {
    rows, cols, err := utils.GetWindowSize()
    if err != nil {
        utils.SafeExit(f, err)
    }

    return &EditorConfig{
        restoreFunc: f,
        reader:      bufio.NewReader(os.Stdin),
        rows:        rows,
        cols:        cols,
    }
}

File: editor/output.go

func (e *EditorConfig) editorDrawRows() {
    for range e.rows {
        fmt.Fprintf(os.Stdout, "~\r\n")
    }
}

The last line

At the moment we always print the \r\n sequence in all lines making us see a blank line at the bottom and loose the first line, lets fix that

File: editor/output.go

func (e *EditorConfig) editorDrawRows() {
    for y := range e.rows {
        fmt.Fprintf(os.Stdout, "~")

        if y < e.rows-1 {
            fmt.Fprintf(os.Stdout, "\r\n")
        }
    }
}

Enable logging

Because the nature of the application, if we need to print any information about the process, we will need to save it to a file, there comes the log/slog package, so lets setup the logger to work as we like

File: utils/logger.go

package utils

import (
    "fmt"
    "os"
    "path"
    "time"
)

func CreateLoggerFile(userTempDir string) (*os.File, error) {
    now := time.Now()
    date := fmt.Sprintf("%s.log", now.Format("2006-01-02"))

    if err := os.MkdirAll(path.Join(userTempDir, "kilo-go"), 0o755); err != nil {
        return nil, err
    }

    fileFullPath := path.Join(userTempDir, "kilo-go", date)
    file, err := os.OpenFile(fileFullPath, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0o666)
    if err != nil {
        return nil, err
    }

    return file, nil
}

File: main.go

func init() {
    var f *os.File
    var err error
    userTempDir, _ := os.UserConfigDir()
    if f, err = utils.CreateLoggerFile(userTempDir); err != nil {
        utils.SafeExit(nil, err)
    }

    handlerOptions := &slog.HandlerOptions{}
    handlerOptions.Level = slog.LevelDebug

    loggerHandler := slog.NewTextHandler(f, handlerOptions)
    slog.SetDefault(slog.New(loggerHandler))
    ...
}

This will create a log file inside the .config/kilo-go directory with the current date as its name

Append Buffer

It is not a good idea to make a lot of Fprintf since all input/output operations are expensive and can cause unexpected behaviors or screen flickering.

We want to replace all of our Fprintf with code that appends all those strings to a buffer and then write this buffer at the end.

We are going to use one of Go features and create a Writer interface which will save in a byte array the information we pass.

File: appendbuffer/appendbuffer.go

package appendbuffer

type AppendBuffer struct {
    buf []byte
}

func New() *AppendBuffer {
    return &AppendBuffer{}
}

func (ab *AppendBuffer) Write(p []byte) (int, error) {
    ab.buf = append(ab.buf, p...)
    return len(p), nil
}

func (ab *AppendBuffer) Bytes() []byte {
    return ab.buf
}

File: editor/output.go

package editor

import (
    "fmt"
    "os"

    ab "github.com/alcb1310/kilo-go/appendbuffer"
    "github.com/alcb1310/kilo-go/utils"
)

func (e *EditorConfig) editorRefreshScreen() {
    abuf := ab.New()

    fmt.Fprintf(abuf, "%c[2J", utils.ESC)
    fmt.Fprintf(abuf, "%c[H", utils.ESC)

    e.editorDrawRows(abuf)

    fmt.Fprintf(abuf, "%c[H", utils.ESC)

    fmt.Fprintf(os.Stdout, "%s", abuf.Bytes())
}

func (e *EditorConfig) editorDrawRows(abuf *ab.AppendBuffer) {
    for y := range e.rows {
        fmt.Fprintf(abuf, "~")

        if y < e.rows-1 {
            fmt.Fprintf(abuf, "\r\n")
        }
    }
}

Hide the cursor while repainting

There is another possible source of flickering, it's possible that the cursor might be displayed in the middle of the screen somewhere for a split second while it is drawing to the screen. To make sure that doesn't happen, we can hide it while repainting the screen, and show it again once it finishes

File: editor/output.go

func (e *EditorConfig) editorRefreshScreen() {
    ...
    fmt.Fprintf(abuf, "%c[?25l", utils.ESC)
    ...
    fmt.Fprintf(abuf, "%c[?25h", utils.ESC)
    ...
}

Clears lines one at a time

Instead of clearing the entire screen before each refresh, it seems more optional to clear each line as we redraw them. Lets remove the <Esc>[2J escape sequence, and instead put a <Esc>[K sequence at the end of each line we draw

File: editor/output.go

func (e *EditorConfig) editorRefreshScreen() {
    abuf := ab.New()

    fmt.Fprintf(abuf, "%c[?25l", utils.ESC)
    fmt.Fprintf(abuf, "%c[H", utils.ESC)

    e.editorDrawRows(abuf)
    ...
}

func (e *EditorConfig) editorDrawRows(abuf *ab.AppendBuffer) {
    for y := range e.rows {
        fmt.Fprintf(abuf, "~")

        fmt.Fprintf(abuf, "%c[K", utils.ESC)
        if y < e.rows-1 {
            fmt.Fprintf(abuf, "\r\n")
        }
    }
}

Welcome message

It is finally time we will display a welcome message to our editor

File: editor/output.go

func (e *EditorConfig) editorDrawRows(abuf *ab.AppendBuffer) {
    for y := range e.rows {
        if y == e.rows/3 {
            welcomeMessage := fmt.Sprintf("Kilo editor -- version %s", utils.KILO_VERSION)
            fmt.Fprintf(abuf, "%s", welcomeMessage)
        } else {
            fmt.Fprintf(abuf, "~")
        }
        ...
    }
}

File: utils/constants.go

package utils

const (
    ESC = 0x1b

    KILO_VERSION = "0.0.1"
)

Center the message

Now that we've shown the welcome screen, it seems odd with the message not centered, so lets do that

File: editor/output.go

func (e *EditorConfig) editorDrawRows(abuf *ab.AppendBuffer) {
    for y := range e.rows {
        if y == e.rows/3 {
            welcomeMessage := fmt.Sprintf("Kilo editor -- version %s", utils.KILO_VERSION)
            welcomeLen := len(welcomeMessage)
            if welcomeLen > e.cols {
                welcomeLen = e.cols
            }

            padding := (e.cols - welcomeLen) / 2
            if padding > 0 {
                fmt.Fprintf(abuf, "~")
                padding--
            }

            for range padding {
                fmt.Fprintf(abuf, " ")
            }

            fmt.Fprintf(abuf, "%s", welcomeMessage)
        ...
    }
}

Create a Text Editor With Go - Enter raw mode

Andres Court — Wed, 05 Nov 2025 21:55:22 +0000

After Setting Up our project, we are ready to start coding.

You can access the code of this chapter in the Kilo-Go github repository in the rawmode branch

Currently your file structure should look something like this:

We will need to create a new file main.go where we will read keypresses from the user

package main

import (
    "bufio"
    "fmt"
    "io"
    "os"
)

func main() {
    r := bufio.NewReader(os.Stdin)

    for {
        _, err := r.ReadByte()
        if err == io.EOF {
            break
        } else if err != nil {
            fmt.Fprintf(os.Stderr, "Error: reading key from Stdin: %s\n", err)
            os.Exit(1)
        }
    }
}

With the code above we are reading and displaying the keypresses, but at the moment we will need to press Ctrl-C to quit the application, so lets give the option to the user when they press q to quit the application, so in our main.go file we will add the following:

func main() {
    ...

    for {
        b, err := r.ReadByte()
        ....

        if b == 'q' {
            break
        }
    }
}

Now once we press q the application will close, but we are reading from input until the user press the Enter key, not the behavior we want, so lets turn on raw mode

First in the command line, we will need to add the library we will be using:

go get golang.org/x/sys/unix

Turn off echoing

The ECHO feature causes each key you type to be printed to the terminal, so you can see what you're typing. This is useful in most cases, but really gets in the way when we are trying to render a user interface in raw mode. So we turn it off. The program still does the same thing as the previous step, but, it just doesn't print what you are typing. After the program quits, you will find that the terminal still doesn't echo what you type, so for now just type reset to go back to normal, and if it doesn't work, just restart your terminal. We will fix that in the next step.

File: linux/raw.go

package linux

import (
    "fmt"

    "golang.org/x/sys/unix"
)

func EnableRawMode() error {
    termios, err := unix.IoctlGetTermios(unix.Stdin, unix.TCGETS)
    if err != nil {
        return fmt.Errorf("EnableRawMode: error getting terminal flags: %w", err)
    }

    termios.Lflag &^= unix.ECHO

    if err = unix.IoctlSetTermios(unix.Stdin, unix.TCSETS, termios); err != nil {
        return fmt.Errorf("EnableRawMode: error setting terminal flags: %w", err)
    }

    return nil
}

File: main.go

import (
    ...
    "github.com/alcb1310/linux"
)

func main() {
    linux.EnableRawMode()
    ...
}

Disable raw mode at exit

File: linux/raw.go

package linux

import (
    "fmt"
    "os"

    "golang.org/x/sys/unix"
)

func EnableRawMode() (func(), error) {
    termios, err := unix.IoctlGetTermios(unix.Stdin, unix.TCGETS)
    if err != nil {
        return nil, fmt.Errorf("EnableRawMode: error getting terminal flags: %w", err)
    }

    original := *termios

    termios.Lflag &^= unix.ECHO

    if err = unix.IoctlSetTermios(unix.Stdin, unix.TCSETS, termios); err != nil {
        return nil, fmt.Errorf("EnableRawMode: error setting terminal flags: %w", err)
    }

    return func() {
        if err := unix.IoctlSetTermios(unix.Stdin, unix.TCSETS, &original); err != nil {
            fmt.Fprintf(os.Stderr, "DisableRawMode: error setting terminal flags: %s\n", err)
            os.Exit(1)
        }
    }, nil
}

File: main.go

func main() {
    restoreFunc, err := linux.EnableRawMode()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error: %s\n", err)
        os.Exit(1)
    }
    defer restoreFunc()
    ...
}

Now we are returning a function that allows us to restore the user's terminal to its original attributes when our program exits.

The defer statement will execute the function once the function ends. If we exit the program from another file, this function will not run, we will fix that later in the tutorial.

Turn off Canonical mode

There is an ICANON flag that allows us to turn off cannonical mode, this means that we will finally be reading byte-by-byte instead of line-by-line.

File: linux/raw.go

func EnableRawMode() (func(), error) {
    ...
    termios.Lflag &^= unix.ECHO | unix.ICANON
    ...
}

Now the program will quit as soon as you press q

Display keypresses

We will like to see what the user is pressing, for the time being, we will show:

In the case of a control-key combo, the key code
In all other cases, the key pressed and the key code

File: main.go

func main() {
        ...
        if b <= 0x1f || b == 0x7f { // This will make sure we've pressed a control-key combo
            fmt.Fprintf(os.Stdout, "%d\n", b)
        } else {
            fmt.Fprintf(os.Stdout, "%d (%c)\n", b, b)
        }
        ...
}

Turn off `Ctrl-C` and `Ctrl-Z` signals

By default, Ctrl-C sends a SIGINT signal to the current process which causes it to terminate, and Ctrl-Z sends a SIGSTOP signal which causes the process to suspend, lets disable them

File: linux/raw.go

func EnableRawMode() (func(), error) {
    ...
    termios.Lflag &^= unix.ECHO | unix.ICANON | unix.ISIG
    ...
}

Turn off `Ctrl-S` and `Ctrl-Q` signals

By default, Ctrl-S and Ctrl-Q are used for software flow control, Ctrl-S stops data from being transmitted until you press Ctrl-Q. This originates in the days you might want to pause data transmission to let a device to catch up (eg. wait for a printer), lets disable them

File: raw/raw.go

func EnableRawMode() (func(), error) {
    ...
    termios.Iflag &^= unix.IXON
    ...
}

Disable `Ctrl-V`

On some systems when you type Ctrl-V, the terminal waits for you to type another character and then sends the last character, we want to disable it

File: linux/raw.go

func EnableRawMode() (func(), error) {
    ...
    termios.Lflag &^= unix.ECHO | unix.ICANON | unix.IEXTEN | unix.ISIG
    ...
}

Fixing `Ctrl-M`

If you run the program now and go through the whole alphabet while holding down the Ctrl key, you will see that Ctrl-J and Ctrl-M gives us the same value. This is due to (13 is /r) Enter which is 13 is interpreted as carriage return and in translated to \n which is 10, so lets turn off this feature.

File: linux/raw.go

func EnableRawMode() (func(), error) {
    ...
    termios.Iflag &^= unix.ICRNL | unix.IXON
    ...
}

Turn off all output processing

The terminal translates the new line (\n) character to (\r\n), it requires both of this characters in order to start a new line. The carriage return (\r) moves the cursor back to the beginning of the current line, and the the new line (\n) moves the cursor down a line, scrolling the screen if necessary. This comes from the era of typewriters. Lets turn off this feature

File: linux/raw

func EnableRawMode() (func(), error) {
    ...
    termios.Oflag &^= unix.OPOST
    ...
    return func() {
        if err = unix.IoctlSetTermios(unix.Stdin, unix.TCSETS, &original); err != nil {
            fmt.Fprintf(os.Stderr, "EnableRawMode: error restoring terminal flags: %s\r\n", err)
            os.Exit(1)
        }
    }, nil
}

File: main.go

func main() {
    restoreFunc, err := linux.EnableRawMode()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error: %s\r\n", err)
        os.Exit(1)
    }
    defer restoreFunc()

    r := bufio.NewReader(os.Stdin)

    for {
        b, err := r.ReadByte()
        if err == io.EOF {
            break
        } else if err != nil {
            fmt.Fprintf(os.Stderr, "Error: reading key from Stdin: %s\r\n", err)
            os.Exit(1)
        }

        if b <= 0x1f || b == 0x7f { // This will make sure we've passed a control-key combo
            fmt.Fprintf(os.Stdout, "%d\r\n", b)
        } else {
            fmt.Fprintf(os.Stdout, "%d (%c)\r\n", b, b)
        }

        if b == 'q' {
            break
        }
    }
}

Miscellaneous flags

Let's turn off a few more flags

File: linux/raw.go

func EnableRawMode() (func(), error) {
    ...
    termios.Iflag &^= unix.BRKINT | unix.ICRNL | unix.INPCK | unix.ISTRIP | unix.IXON
    termios.Cflag |= unix.CS8
    ...
}

With this step you will most likely won't see any effect, but turning them off was considered to be part of enabling raw mode, so we carry on the tradition, what I've learned about the flags used:

BRKINT: when turned on is a break condition that will cause a SIGINTto be sent to the program just like pressing Ctrl-C
INPCK: enables parity checking
ISTRIP: causes the 8th bit of each input byte to be stripped, meaning it will set it to 0. This is probably already turned off.
CS8: this is not a flag, it is a bit mask which sets the character size (CS) to 8 bits per byte.

Refactor: Use interface for enabling raw mode

Interfaces are a common used patter in Go, so we are going to use it here, so if we want to add Mac and Windows support, we can just add a struct that implements that interface

File: linux/raw.go

type UnixRawMode struct{}

func NewUnixRawMode() *UnixRawMode {
    return &UnixRawMode{}
}

func (r *UnixRawMode) EnableRawMode() (func(), error) {
    ...
}

__File: main.go

type RawMode interface {
    EnableRawMode() (func(), error)
}

type EditorConfig struct {
    restoreFunc func()
}

var editorState EditorConfig = EditorConfig{}

func init() {
    var err error
    u := linux.NewUnixRawMode()
    editorState.restoreFunc, err = u.EnableRawMode()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error: %s\r\n", err)
        os.Exit(1)
    }
}

func main() {
    defer editorState.restoreFunc()
    ...
}

Exit strategy

Now that we have raw mode working, lets improve this by having a centralized way to exit the program so it will manage errors and any exit behavior that we want

File: exit/exit.go

package exit

import (
    "fmt"
    "os"
)

// SafeExit is a function that allows us to safely exit the program
//
// # It will call the provided function and exit with the provided error
// if no error is provided, it will exit with 0
//
// @param f - The function to call
// @param err - The error to exit with
func SafeExit(f func(), err error) {
    if f != nil {
        f()
    }

    if err != nil {
        fmt.Fprintf(os.Stderr, "Error: %s\r\n", err)
        os.Exit(1)
    }

    os.Exit(0)
}

File: linux/raw.go

func (r *UnixRawMode) EnableRawMode() (func(), error) {
    ...
    return func() {
        if err = unix.IoctlSetTermios(unix.Stdin, unix.TCSETS, &original); err != nil {
            exit.SafeExit(nil, fmt.Errorf("EnableRawMode: error restoring terminal flags: %w", err))
        }
    }, nil

}

File: main.go

func main() {
    defer exit.SafeExit(editorState.restoreFunc, nil)
    ...
}

Create a Text Editor With Go - Setup

Andres Court — Tue, 04 Nov 2025 21:30:44 +0000

For a couple of months now, I've been searching for new projects to work on, where I can learn more about Go, and not really wanted to continue with Web Development.

I came across a tutorial where they Build Your Own Text Editor which is using the C language.

This is my attempt on porting that tutorial to Go, this will be divided in several posts that I will be publishing as I continue with the process.

In this first chapter, we will be setting up the project and enter raw mode so we can build from there our text editor.

Setting up the project

Note: This project has been developed and tested on LINUX, if you'd like to port this to Mac or Windows, you are welcome to make a PR in that regard

Requisites

Go language: If you don't have it already installed, you can do it following the installation instructions
A code editor: In this tutorial we will be using NeoVim
A terminal: I will be using Alacritty

Start up

On your terminal we will create the project directory, and initialize the go module:

mkdir kilo-go
cd kilo-go
go mod init github.com/alcb1310/kilo-go

Note: Remember to change the module name for your own

This will be a series of articles where we will be going through all the steps to code the Text Editor

DEV Community: Andres Court

Create an API - Project Setup

Requirements

What are we going to be building

Setting up the project

Enabling Hot Reload

Ignoring files for source contrl

Adding our first route

internal/router/router.go

cmd/api/main.go

Reading from environment

main.go

Deploying the application

Deploying PR

Highlight Multiple Languages

Refactor: move the syntax struct to its own package

Adding C/C++ support

Multilingual support without changing the editor

Adding Config File

Multiplatform support

Install the required dependency

Implementing the feature

Cleaning up unused libraries

Adding a configuration file

Using variables instead of constants

Reading a TOML file

Assigning the values

Create a Text Editor in Go - Syntax Highlighting

Colorful digits

Refactor syntax highlighting

Colorful search results

Restore syntax highlighting after search

Colorful numbers

Detect filetype

Colorful strings

Colorful comments

Colorful keywords

Multiline comments

Create a Text Editor in Go - Search

Search

Refactor: Have editorPrompt to take a callback

Incremental search

Restoring cursor position when canceling query

Search forward and backward

Create a Text Editor in Go - A Text Editor

Insert ordinary characters

Prevent inserting special characters

Save to disk

Dirty flag

Quit confirmation

Simple backspacing

Backspacing at the start of a line

The Enter key

Prompting the user

Save as

Create a Text Editor in Go - Status Bar

Scrolling with Page Up and Page Down

Move to the end of the line with End

Make space for the status bar

Display the status bar

Display the file name

Display the cursor position

Status message

What we've achieved

Create a Text Editor in Go - Text Viewer

A line viewer

Reading command line arguments

Opening the file

Hide the welcome message

Refactor rename rows and cols

Multiple lines

Vertical Scrolling

Horizontal scrolling

Limit scrolling to the right

Snap cursor to end of line

Moving left at the start of a line

Moving right at the end of a line

Rendering tabs

Read the \t character

Tabs and the cursor

Reading a `TOML` file

Refactor: Have `editorPrompt` to take a callback

The `Enter` key

Scrolling with `Page Up` and `Page Down`

Move to the end of the line with `End`

Refactor rename `rows` and `cols`

Read the `\t` character

The `Page Up` and `Page Down` keys

The `Home` and `End` keys

The `Delete` key

Press `Ctrl-Q` to quit

Turn off `Ctrl-C` and `Ctrl-Z` signals

Turn off `Ctrl-S` and `Ctrl-Q` signals

Disable `Ctrl-V`

Fixing `Ctrl-M`