Forem: Andres Court

Testing your routes

Andres Court — Mon, 20 Apr 2026 12:09:38 +0000

If you've been following this tutorial, you'd have the following file structure:

Unit testing

With unit testing we just want to verify that the tested functions work as expected in isolation, so we will mock database behavior. I like having the tests I write next to the files where the functions reside.

file: internal/router/health_test.go

package router_test

import "testing"

func TestHealthRoute(t *testing.T) {
    a := true
    if a {
        t.Log("a is true")
        t.Fail()
    }
}

To run the tests, you have to execute the following command:

go test ./...

With the test we wrote we will expect the following:

Lets fix the previous test so it is a successful test

file: internal/router/health_test.go

package router_test

import "testing"

func TestHealthRoute(t *testing.T) {
    a := false
    if a {
        t.Log("a is true")
        t.Fail()
    }
}

After running the test, this is what we've got

Now that we've seen what a failing and successful test look like lets continue with the process.

The testing library

The method to perform checks in our test works, but it is to verbose in my opinion, luckily there is a library that helps us with that

go get github.com/stretchr/testify

Now that we have the testing library, the code we had before will look like the following:

package router_test

import (
    "testing"

    "github.com/stretchr/testify/assert"
)

func TestHealthRoute(t *testing.T) {
    a := true
    assert.Equal(t, a, false)
}

And its output will be:

With this library we gain two main things:

An easier to read code
A more understandable test results

A successful running test will look the same as before.

Mocking the Database Connection

With what we've got at the moment, we don't have all the tools to test the router, unless we have a database for testing purposes only. There is an application in Go called mockery that we will use to simultate the connection.

To install we need to run:

go install github.com/vektra/mockery/v2@2.53.6

This will install mockery to our system, to check if it is working properly

mockery --version

Setting up Mockery

To setup mockery we need to create a configuration file called .mockery.yaml that should be in the root of our project

all: True
with-expecter: True
output: "internal/mocks"

This configuration file will create mocks for all of our interfaces inside the internal/mocks directory. To generate the mocks we need to run

mockery

Remember do not modify this generated files since they will be modified again on each generation. On finish this will be our tree file structure

Writing our first test

In the health_test.go file we need to do the following changes:

file: internal/router/health_test.go

package router_test

import (
    "testing"

    "github.com/alcb1310/bookstore/internal/mocks"
    "github.com/alcb1310/bookstore/internal/router"
    "github.com/stretchr/testify/assert"
)

func TestHealthRoute(t *testing.T) {
    db := mocks.NewService(t)
    s := router.New(8080, db)
    s.Router()
    assert.NotNil(t, s)
}

If we run this test, we will find that the test will be waiting for requests, and will not continue executing, so we will need to refactor our code so that the listening for connection occurs in the main function

file: internal/router/router.go

package router

import (
    "time"

    "github.com/alcb1310/bookstore/internal/database"
    "github.com/go-chi/chi/v5"
    "github.com/go-chi/chi/v5/middleware"
    "github.com/go-chi/httprate"
)

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

r.Use(middleware.RealIP)
r.Use(middleware.Logger)
r.Use(middleware.CleanPath)
r.Use(middleware.Recoverer)
r.Use(httprate.LimitByIP(100, 1*time.Minute))

r.Get("/", HandleErrors(HomeRoute))
r.Get("/health", HandleErrors(s.HealthRoute))

return r

}

So now in our router function, we just return the mux structure which will enable us to listen for connections on the main function

file: cmd/api/main.go

package main

import (
    "fmt"
    "log/slog"
    "net/http"
    "os"
    ...
)

func main() {
    ...

    s := router.New(port, db)
    slog.Info("Starting server", "port", port)
    h := s.Router()
    if err := http.ListenAndServe(fmt.Sprintf(":%d", port), h); err != nil {
        panic(err)
    }
}

If we now run our test, we will have a successful test

Testing the happy path

Now lets write a test where we can verify we get the expected result when the database is working correctly

file: internal/router/health_test.go

package router_test

import (
    "encoding/json"
    "net/http"
    "net/http/httptest"
    "testing"

    "github.com/alcb1310/bookstore/internal/mocks"
    "github.com/alcb1310/bookstore/internal/router"
    "github.com/stretchr/testify/assert"
)

func TestHealthRoute(t *testing.T) {
    db := mocks.NewService(t)
    s := router.New(8080, db)
    s.Router()
    assert.NotNil(t, s)

    testURL := "/health"

    db.EXPECT().HealthCheck().Return(nil).Times(1)

    req, err := http.NewRequest(http.MethodGet, testURL, nil)
    assert.NoError(t, err)

    rec := httptest.NewRecorder()
    s.Router().ServeHTTP(rec, req)

    responseBody := map[string]any{}
    err = json.Unmarshal(rec.Body.Bytes(), &responseBody)
    assert.NoError(t, err)

    assert.Equal(t, http.StatusOK, rec.Code)
    assert.Equal(t, "ok", responseBody["status"])
}

Testing the Error reponses

Right know we've mocked the health database response, but we need to test also the error responses, but with the approach we currently have, we need to create a new function for each case, so let's refactor our test to be able to test multiple cases in the same function

file: internal/router/health_test.go

...

func TestHealthRoute(t *testing.T) {
    db := mocks.NewService(t)
    s := router.New(8080, db)
    s.Router()
    assert.NotNil(t, s)

    testURL := "/health"

    testCases := []struct {
        name     string
        status   int
        response map[string]any
        check    *mocks.Service_HealthCheck_Call
    }{
        {
            name:   "should return ok",
            status: http.StatusOK,
            response: map[string]any{
                "status": "ok",
            },
            check: db.EXPECT().HealthCheck().Return(nil),
        },
    }

    for _, tc := range testCases {
        t.Run(tc.name, func(t *testing.T) {
            if tc.check != nil {
                tc.check.Times(1)
            }

            req, err := http.NewRequest(http.MethodGet, testURL, nil)
            assert.NoError(t, err)

            rec := httptest.NewRecorder()
            s.Router().ServeHTTP(rec, req)

            responseBody := map[string]any{}
            err = json.Unmarshal(rec.Body.Bytes(), &responseBody)
            assert.NoError(t, err)

            assert.Equal(t, tc.status, rec.Code)
            assert.Equal(t, tc.response, responseBody)
        })
    }
}

With this refactor, we have the same test as we had before, now lets create another test case, where we mock an error response from the database

file: internal/router/health_test.go

package router_test

import (
    "encoding/json"
    "fmt"
    ...

    "github.com/alcb1310/bookstore/internal/interfaces"
    ...
)

func TestHealthRoute(t *testing.T) {
    ...

    testCases := []struct {
        name     string
        status   int
        response map[string]any
        check    *mocks.Service_HealthCheck_Call
    }{
        ...
        {
            name:   "database is not available",
            status: http.StatusGatewayTimeout,
            response: map[string]any{
                "error": "Database is not available",
            },
            check: db.EXPECT().HealthCheck().Return(&interfaces.APIError{
                Code:          http.StatusGatewayTimeout,
                Msg:           "Database is not available",
                OriginalError: fmt.Errorf("database is not available"),
            }),
        },
    }

    ...
}

As you can see, with this way of creating tests, it is very easy to add new test cases. We have just one final test case we can add by mocking and that is what will happen when we get an unknown error

file: internal/router/health_test.go

...

func TestHealthRoute(t *testing.T) {
    ...

    testCases := []struct {
        name     string
        status   int
        response map[string]any
        check    *mocks.Service_HealthCheck_Call
    }{
        ...
        {
            name:   "unknown error",
            status: http.StatusInternalServerError,
            response: map[string]any{
                "error": "Unknown database error",
            },
            check: db.EXPECT().HealthCheck().Return(fmt.Errorf("Unknown database error")),
        },
    }

    ...
}

Integration Tests

At the moment we've learned how to create unit tests, which are very fast to execute, but we need to mock the database connection, so, in order to do that we have integration tests. This kind of tests are much slower but you can simulate the real environment and test around it.

First we need to install the test containers package

go get github.com/testcontainers/testcontainers-go
go get github.com/testcontainers/testcontainers-go/modules/postgres

Since we need to create a testing database to use, we need to move the database connection string out to the main function

file internal/database/database.go

...

func New(url string) (Service, error) {
    if url == "" {
        return nil, fmt.Errorf("DATABASE_URL is not set")
    }

    ...
}

file cmd/api/main.go

...

func main() {
    ...

    url := os.Getenv("DATABASE_URL")
    db, err := database.New(url)
    if err != nil {
        slog.Error("Error connecting to database", "error", err)
        panic(err)
    }

    ...
}

First integration test

Now that we have our configuration ready, lets write our first integration test

file tests/health_test.go

package tests

import (
    "context"
    "testing"
    "time"

    "github.com/stretchr/testify/assert"
    "github.com/testcontainers/testcontainers-go"
    "github.com/testcontainers/testcontainers-go/modules/postgres"
    "github.com/testcontainers/testcontainers-go/wait"
)

func TestHealthEndPoint(t *testing.T) {
    ctx := context.Background()

    pgContainer, err := postgres.Run(ctx,
        "postgres:18-alpine",
        postgres.WithDatabase("bookstore"),
        postgres.WithUsername("postgres"),
        postgres.WithPassword("postgres"),
        testcontainers.WithWaitStrategy(
            wait.ForLog("database system is ready to accept connections").
                WithOccurrence(2).
                WithStartupTimeout(15*time.Second)),
    )

    assert.NotNil(t, pgContainer)
    assert.NoError(t, err)

    t.Cleanup(func() {
        if pgContainer != nil {
            err = pgContainer.Terminate(ctx)
            assert.NoError(t, err)
        }
    })
}

This test will create a Docker container with an instance of a PostgreSQL 18 database named bookstore, validates that the container is started correctly and when the test ends, it will terminate the container

Lets test that it can connect to a database

file tests/common.go

package tests

import (
    "context"
    "fmt"
    "testing"

    "github.com/alcb1310/bookstore/internal/database"
    "github.com/alcb1310/bookstore/internal/router"
    "github.com/stretchr/testify/assert"
    "github.com/testcontainers/testcontainers-go/modules/postgres"
)

func createServer(t *testing.T, ctx context.Context, pgContainer *postgres.PostgresContainer) (*router.Router, error) {
    connStr, err := pgContainer.ConnectionString(ctx, "sslmode=disable")
    assert.NoError(t, err)
    db, _ := database.New(connStr)
    assert.NotNil(t, db)
    if db == nil {
        return nil, fmt.Errorf("db is nil")
    }

    s := router.New(0, db)
    return s, err
}

file: tests/health_test.go

package tests

import (
    ...
    "encoding/json"
    "net/http"
    "net/http/httptest"
    ...

    "github.com/stretchr/testify/assert"
    "github.com/testcontainers/testcontainers-go"
    "github.com/testcontainers/testcontainers-go/modules/postgres"
    "github.com/testcontainers/testcontainers-go/wait"
)

func TestHealthEndPoint(t *testing.T) {
    ...

    testURL := "/health"
    s, err := createServer(t, ctx, pgContainer)
    assert.NoError(t, err)
    assert.NotNil(t, s)

    t.Run("Integration - should return ok", func(t *testing.T) {
        expected := map[string]any{"status": "ok"}
        req, err := http.NewRequest("GET", testURL, nil)
        assert.NoError(t, err)
        res := httptest.NewRecorder()
        s.Router().ServeHTTP(res, req)

        assert.Equal(t, http.StatusOK, res.Code)
        responseBody := map[string]any{}
        err = json.Unmarshal(res.Body.Bytes(), &responseBody)
        assert.NoError(t, err)
        assert.Equal(t, expected, responseBody)
    })
}

Error simulation

We've currently tested what will happen if we can connect properly to the database, but, what will happen if our application looses connection for whatever reason to the database, in that scenario, we expect an error to occur, so lets test that

file tests/health_test.go

...

func TestHealthEndPoint(t *testing.T) {
    ...

    t.Run("Integration - database is not available", func(t *testing.T) {
        err := pgContainer.Terminate(ctx)
        assert.NoError(t, err)
        pgContainer = nil
        expected := map[string]any{"error": "Database is not available"}
        req, err := http.NewRequest("GET", testURL, nil)
        assert.NoError(t, err)
        res := httptest.NewRecorder()
        s.Router().ServeHTTP(res, req)

        assert.Equal(t, http.StatusServiceUnavailable, res.Code)
        responseBody := map[string]any{}
        err = json.Unmarshal(res.Body.Bytes(), &responseBody)
        assert.NoError(t, err)
        assert.Equal(t, expected, responseBody)
    })
}

Adding GitHub actions

Finally after we are done setting up our tests, we need to ensure we are only able to merge our PRs only if all of our tests complete successfully, to do so, we need to create GitHub Actions. Even though you can run both integration and unit tests at once, I prefer to run them separately, that way I can better understand where did something went wrong.

file: .github/workflows/unit-test.yml

name: Unit Tests
on: pull_request

jobs:
  unit-test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Set up Go
        uses: actions/setup-go@v4
        with:
          go-version: 1.25
      - name: Run tests
        run: go test ./internal/...

file: .github/workflows/integration-test.yml

name: IntegrationTests

on: pull_request

jobs:
  integration-test:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v3
      - name: Set up Go
        uses: actions/setup-go@v4
        with:
          go-version: 1.25
      - name: Run tests
        run: go test ./tests/...

Now that we have all our workflows created, we need to enforce them in our code, so in your project's GitHub, lets go to the settings page, then select the ruleset page inside the rules category. In that page select New ruleset button.

As the rule name, I like to use the target branch name
As the target, since we are targeting the master branch, then lets select the *include default branch" option
Select the Require status checks to pass and add there both of the workflows we've created

Finally we can accept the changes and we are done, if we create a test that is unsuccessfull, we wont be able to merge the pull request inside of GitHub

Summary

In this article we created unit and integration tests for our application and wrote some GitHub workflows to enforce that the tests are successfull before we are allowed to merge our changes

Connecting to a Database

Andres Court — Fri, 10 Apr 2026 00:55:03 +0000

If you've been following this series, your directory structure should look something like this:

Handling Errors

In order to standarize the error response, it is recommended to create a helper function to handle it. If you see the Get function, one of its parameters is a handler function, so lets create one

file: internal/router/common.go

package router

import "net/http"

type ErrorResponse func(w http.ResponseWriter, r *http.Request) error

func HandleErrors(h ErrorResponse) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        if err := h(w, r); err != nil {
            http.Error(w, err.Error(), http.StatusInternalServerError)
        }
    }
}

func HomeRoute(w http.ResponseWriter, r *http.Request) error {
    _, err := w.Write([]byte("Hello world"))
    return err
}

Now lets wrap the Get function in our error response

file: internal/router/router.go

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

    r.Get("/", HandleErrors(HomeRoute))

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

Now we have a centralized way to handle any error that we find in our project.

Returning JSON response

It is common that an API returns a JSON response, this will give the frontend a standarize way to receive and process the information provided.

file: internal/router/common.go

package router

import (
    "encoding/json"
    "net/http"
)

...

func HomeRoute(w http.ResponseWriter, r *http.Request) error {
    return JSONResponse(w, http.StatusOK, map[string]any{"message": "Hello world"})
}

func JSONResponse(w http.ResponseWriter, code int, data map[string]any) error {
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(code)
    return json.NewEncoder(w).Encode(data)
}

Health endpoint

Now lets create a health endpoint, which will be in charge of checking that all the dependencies of our project are working correctly

file: internal/router/health.go

package router

import "net/http"

func HealthRoute(w http.ResponseWriter, r *http.Request) error {
    return JSONResponse(w, http.StatusOK, map[string]any{"status": "ok"})
}

file: internal/router/router.go

...
func (s *service) Router() error {
    ...
    r.Get("/health", HandleErrors(HealthRoute))
    ...
}

Database connection

Now we have all the components so we can connect to a database and check if everything is correctly working, first we need to install the package to connect to a PostgreSQL database

go get github.com/jackc/pgx/v5

Next we will create a database package where we will keep all the database interaction function

file: internal/database/database.go

package database

import (
    "database/sql"
    "os"

    _ "github.com/jackc/pgx/v5"
)

type Service interface{}

type service struct {
    DB *sql.DB
}

func New() (Service, error) {
    conn, err := sql.Open("pgx", os.Getenv("DATABASE_URL"))
    if err != nil {
        return nil, err
    }

    return &service{
        DB: conn,
    }, nil
}

file: internal/router/router.go

...
import (
    ...
    "github.com/alcb1310/bookstore/internal/database"
    ...
)

type service struct {
    port uint16
    db   database.Service
}

func New(port uint16, db database.Service) *service {
    return &service{
        port: port,
        db:   db,
    }
}
...

file: cmd/api/main.go

...
import (
    ...
    "github.com/alcb1310/bookstore/internal/database"
    ...
)

func main() {
    ...
    db, err := database.New()
    if err != nil {
        slog.Error("Error connecting to database", "error", err)
        panic(err)
    }

    s := router.New(port, db)
    ...
}

Updating the Health endpoint

Now that we are connected to the database we need to have the capacity to check if the database is still available

file: internal/database/database.go

...
type Service interface {
    HealthCheck() error
}
...
func (s *service) HealthCheck() error {
    return s.DB.Ping()
}

file: internal/router/health.go

package router

import "net/http"

func (s *service) HealthRoute(w http.ResponseWriter, r *http.Request) error {
    if err := s.db.HealthCheck(); err != nil {
        return err
    }

    return JSONResponse(w, http.StatusOK, map[string]any{"status": "ok"})
}

file: internal/router/router.go

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

    r.Get("/", HandleErrors(HomeRoute))
    r.Get("/health", HandleErrors(s.HealthRoute))

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

Handling errors

At the moment, we are returning to much information to the user, information that should be logged, but not something to show the final user. First we will need to implement an error structure for the api

file internal/interfaces/apierror.go

package interfaces

type APIError struct {
    Code          int
    Msg           string
    OriginalError error
}

func (e *APIError) Error() string {
    return e.Msg
}

file internal/router/common.go

package router

import (
    ...
    "errors"
    "log/slog"

    "github.com/alcb1310/bookstore/internal/interfaces"
)

type ErrorResponse func(w http.ResponseWriter, r *http.Request) error

func HandleErrors(h ErrorResponse) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        if err := h(w, r); err != nil {
            if e, ok := errors.AsType[*interfaces.APIError](err); ok {
                slog.Error("API error", "code", e.Code, "error", e.OriginalError)
                _ = JSONResponse(w, e.Code, map[string]any{"error": e.Msg})
                return

            }

            slog.Error("Internal server error", "error", err)
            _ = JSONResponse(w, http.StatusInternalServerError, map[string]any{"error": err.Error()})
        }
    }
}
...

Finally, errors should be coded where it occurs, so we edit the health check function

file: internal/database/database.go

package database

import (
    "context"
    "database/sql"
    "errors"
    "fmt"
    "net/http"
    "os"

    "github.com/alcb1310/bookstore/internal/interfaces"
    "github.com/jackc/pgx/v5/pgconn"
    _ "github.com/jackc/pgx/v5/stdlib"
)

...

func (s *service) HealthCheck() error {
    if err := s.DB.Ping(); err != nil {
        if e, ok := errors.AsType[*pgconn.PgError](err); ok {
            switch e.Code {
            case "3D000":
                return &interfaces.APIError{
                    Code:          http.StatusGatewayTimeout,
                    Msg:           "Database is not available",
                    OriginalError: e,
                }
            case "28000":
                return &interfaces.APIError{
                    Code:          http.StatusBadGateway,
                    Msg:           "Database is not available",
                    OriginalError: e,
                }
            default:
                return &interfaces.APIError{
                    Code:          http.StatusInternalServerError,
                    Msg:           "Database is not available",
                    OriginalError: e,
                }
            }
        }
        if _, ok := errors.AsType[*pgconn.ConnectError](err); ok {
            return &interfaces.APIError{
                Code:          http.StatusServiceUnavailable,
                Msg:           "Database is not available",
                OriginalError: err,
            }
        }

        return err
    }

    return nil
}

With this we are returning proper errors to the user, with specific Http Error Codes according on what have happened to the database connection, but, if we loose network connection, then the application hangs up. To solve this we have the context api and the PingContext function where we can establish a time limit to a process, so we will wait at most for 5 seconds before an error happens

package database

import (
    ...
    "time"
    ...
)

...

func (s *service) HealthCheck() error {
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()

    if err := s.DB.PingContext(ctx); err != nil {
        ...
    }

    return nil
}

Adding middleware

Middleware are functions we run before the route itself runs, there are plenty of things we can use a middleware for, such as authentication and authorizatin, logging, among others, so lets add some to our application

What every of the middleware we add here does can be found in the Go chi middleware documentation page

To enable the httprate middleware, we will need to add its package

go get github.com/go/chi/httprate

file internal/router/router.go

package router

import (
    ...
    "time"

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

...

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

    r.Use(middleware.RealIP)
    r.Use(middleware.Logger)
    r.Use(middleware.CleanPath)
    r.Use(middleware.Recoverer)
    r.Use(httprate.LimitByIP(100, 1*time.Minute))

    ...
}

To test the rate limiter, I've created a short script that is part of the project's repo

file: cmd/scripts/rate

!# /bin/bash

source .env
start=$EPOCHREALTIME

for i in {1..103}
do
    echo "Request $i"
    curl http://localhost:$PORT
done

end=$EPOCHREALTIME

echo "Elapsed: $(echo "$end - $start" | bc) seconds"

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)
        ...
    }
}

Forem: Andres Court

Testing your routes

Unit testing

file: internal/router/health_test.go

file: internal/router/health_test.go

The testing library

Mocking the Database Connection

Setting up Mockery

Writing our first test

file: internal/router/health_test.go

file: internal/router/router.go

file: cmd/api/main.go

Testing the happy path

file: internal/router/health_test.go

Testing the Error reponses

file: internal/router/health_test.go

file: internal/router/health_test.go

file: internal/router/health_test.go

Integration Tests

file internal/database/database.go

file cmd/api/main.go

First integration test

file tests/health_test.go

file tests/common.go

file: tests/health_test.go

Error simulation

file tests/health_test.go

Adding GitHub actions

file: .github/workflows/unit-test.yml

file: .github/workflows/integration-test.yml

Summary

Connecting to a Database

Handling Errors

file: internal/router/common.go

file: internal/router/router.go

Returning JSON response

file: internal/router/common.go

Health endpoint

file: internal/router/health.go

file: internal/router/router.go

Database connection

file: internal/database/database.go

file: internal/router/router.go

file: cmd/api/main.go

Updating the Health endpoint

file: internal/database/database.go

file: internal/router/health.go

file: internal/router/router.go

Handling errors

file internal/interfaces/apierror.go

file internal/router/common.go

file: internal/database/database.go

Adding middleware

file internal/router/router.go

file: cmd/scripts/rate

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

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