kiyra

kiyra@midnight:~$ whoami

Some people decorate a room. I decorate a prompt.

I'm kiyra — etokiyra on GitHub. I build compilers, terminal tools, and small playable worlds, usually because I want to know what happens if I make the whole thing myself.

  • Rust
  • Go
  • compilers
  • terminal UIs
  • Linux
explore the projects github.com/etokiyra (opens in a new tab)

currently building a compiler that compiles itself.

suzu — terminal familiar

asleep at 02:14

a small guardian for the dark hours

01 / about

the short version

I learn by making
the thing.

I'm less interested in collecting frameworks than in understanding the layer underneath them. A compiler, a renderer, an audio pipeline, a terminal UI — each one is a chance to take the lid off and see how the trick works.

Most of what I make assumes a Linux terminal. I like software that can be read, rebuilt, and understood: small tools with clear jobs, interfaces that stay out of the way, and defaults that respect the person using them. The fact that a terminal can be a code editor, a record deck, and a dark forest at the same time still feels like a small miracle.

The thread through all of it is curiosity about the machine — not just what it can do, but why it does it that way, and what happens if you build it differently.

The interesting part isn't that it works. It's knowing why it works.

02 / projects

pinned & in progress

Four things I keep
building.

These are the repositories pinned on my GitHub. All of them are works in progress; the interesting part is the engineering underneath. No stars, no download counters — just what each one is trying to do.

01 Rust · MPL-2.0 active

Koda

an IDE that arrives already knowing the language

Koda is a terminal-native development environment built around one promise: install it, open a project, start coding. No plugin marketplace, no hand-written LSP config. It detects the language, brings built-in intelligence, and hands over to a language server when one is available — including fetching and verifying the toolchain itself.

The most interesting part is where the complexity went. Language-specific logic is kept out of the editor and UI. Detection combines filenames, shebangs, extensions, content, and project markers. Expensive work runs on a background worker, so the interface stays quiet while the machinery underneath does the hard part.

  • Built-in diagnostics, completion, symbols and navigation keep working offline.
  • Managed toolchains are checksum- or signature-verified and isolated under Koda's own directory.
  • Transparent by default: the terminal's background, blur and wallpaper stay visible.
  • Rust
  • TUI
  • LSP
  • developer tools
open koda (opens in a new tab)
✦ kodasrc/main.rs
 ──────────────────────────────────────────────
   ▸ src          1  use std::io;
   ▸ app          2
   · Cargo.toml   3  fn main() {
   · README.md    4      let name = "koda";
                  5      print(name);
                  6  }
 ──────────────────────────────────────────────
   Rust   ✓ lsp   ☾ main      Ln 5, Col 3

A glyph sketch of the idea — not a screenshot.

02 Go · C · GPL-3.0 v0.1 · early

Kitten

a small language learning to compile itself

Kitten is a statically typed, garbage-collected language that compiles to native executables. The source shape comes from C#, the smallness and tooling culture from Go, and the ecosystem ambition from Rust. The command-line tool is called purr; the files are .ktn.

The compiler is written in Go and emits C, which the host C compiler turns into a binary. A second compiler, written in Kitten, is being built one stage at a time and checked against the Go reference. It has reached the C-level fixpoint: stages 1, 2, and 3 emit byte-identical C. Go still builds stage 1, so this is a precise milestone — not a claim that the bootstrap is gone.

  • SPEC.md is the source of truth; semantics are not silently invented in code.
  • Differential harnesses compare the self-hosted stages against the Go implementation.
  • The toolchain is GPL-3.0-or-later; the runtime is MIT, so compiled programs stay yours.
  • Go
  • C
  • compilers
  • self-hosting
open kitten (opens in a new tab)
kittenhello.ktn → native
      hello.ktn
          │
          ▼
  ┌────────┐   ┌────────┐   ┌─────────┐
  │ lexer  │──▶│ parser │──▶│ checker │
  └────────┘   └────────┘   └─────────┘
                                 │
                                 ▼
                            ┌─────────┐
                            │ codegen │──▶ hello
                            └─────────┘

   go ref ──▶ s1 ──▶ s2 ──▶ s3
     same C, byte for byte

The self-hosting path, reduced to its shape.

03 Go · GPL-3.0 active

vynl

a DJ booth that fits in your terminal

vynl turns a local music folder into a live console: a rotating vinyl deck, a real FFT spectrum analyzer, stereo meters, and independent tempo, pitch, volume, and 3-band EQ controls. It plays MP3, FLAC, WAV, and OGG without a browser, a GUI, or a service in the middle.

Under the deck is a serious audio engine. A bounded PCM ring keeps memory flat, gapless playback keeps one output stream alive across tracks, and an optional equal-power crossfade joins them. Playlists are plain M3U8 files. The terminal paints no background, so your own theme and transparency show through.

  • A 1024-point FFT, Hann-windowed, mapped to 48 log-spaced bands with peak hold.
  • Tempo and pitch move independently; vinyl mode couples them like a turntable.
  • Live ReplayGain, crossfade, EQ, shuffle and repeat without restarting playback.
  • Go
  • Bubble Tea
  • audio DSP
  • M3U8
open vynl (opens in a new tab)
vynldeck · 33⅓
        .-~~~~~~~~~~~~-.
      .'   ╭────────╮   '.
     /    /  ░░░░░░  \    \
    |    |  ░░██░░░░ |    |
    |    |  ░░██░░░░ |    |
     \    \  ░░░░░░  /    /
      '.   ╰────────╯   .'
        '-~~~~~~~~~~~~-'
   ▂▄▆█▆▄▂   ▂▄▆█▆▄▂   ▂▄▆█▆▄▂
   tempo 1.00×  pitch +0  vol 76

A record, a spectrum, and a very small dance floor.

04 Rust · GPL-3.0 early

Grimmoire

a dark-fantasy world drawn entirely in glyphs

Grimmoire is an ASCII-first RPG set in a village that survived a drought by feeding the water, and a shrine that has spent four hundred years making sure nobody finishes the sentence that would end it. You explore six connected places, talk to nine characters, keep a journal of what you discover, and solve one puzzle written on the floor.

The renderer is the project. Every wall, candle, and face is a cell in a grid that Grimmoire owns. Walls get lit caps and shadowed bases from their neighbours; floors are textured by world position so they never shimmer; light falls off with distance. Even the cast is source text — seven cells wide, five tall, eight inks — with no image files underneath.

  • Branching conversations remember what you asked, refused, or pressed.
  • Discoveries change what characters say, and sometimes change the room itself.
  • Runs in Kitty at 80×24 or larger; below that it suspends rather than draws noise.
  • Rust
  • ASCII renderer
  • game design
  • Kitty
open grimmoire (opens in a new tab)
grimmoireruined chapel
   ░░░░░░░░░░░░░░░░░░░░░░░░░
   ░   ▄▄        ·      ▄   ░
   ░  ████     @       ██   ░
   ░   ██     /|\   ░  ██   ░
   ░          / \  ░░░      ░
   ░░░░░░░░░░░░░░░░░░░░░░░░░
     the chapel remembers.

A glyph sketch of the chapel — not a screenshot.

03 / interests

what pulls me in

The layer underneath
the layer.

A compact map of the things I keep returning to. Not a skill meter — just the problems that make me open a terminal at midnight.

compilers & languages

Lexers, type checkers, code generation, and the quiet argument between a specification and its implementation.

terminal interfaces

Layouts that fit in cells, keymaps that make sense, and animation that survives a slow SSH connection.

systems & runtimes

Garbage collectors, renderers, audio pipelines: the parts that make the surface feel effortless.

tools with manners

Software with a narrow job, zero-config defaults, and no reason to phone home.

Linux & open source

Readable code, buildable projects, and the freedom to take something apart and put it back differently.

the feel of software

A status line, a loading state, a pause. Craft is also interface, and interface is also engineering.

The ground floor is Linux, a terminal, and a stubborn willingness to read the source.

04 / notes

habits & experiments

Curiosity,
compiled.

I don't have a grand theory of software. I have a few habits that keep showing up in the repos — and a desk full of things I'm still figuring out.

01

the spec comes first

Kitten's SPEC.md is the source of truth. If code and the specification disagree, the specification wins until it is deliberately changed. It is a small rule with a large effect: it keeps design from becoming an accident.

02

verify against the boring version

The self-hosted compiler is not trusted because it seems to work. Its lexer, parser, checker, code generator, and driver are compared with the Go reference across thousands of inputs, down to diagnostics and positions. "Same output" is a stronger claim than "it runs."

03

the interface is part of the system

A terminal renderer has to care about character widths, cursor placement, and the cost of a repaint. A music player has to care about a dropped buffer. The visible polish is never separate from the engineering underneath it.

$ ls ~/desk

only what is actually in the repos

  • kitten a Kitten-written build path growing beside the authoritative Go compiler.
  • koda language support, managed toolchains, and the unglamorous work of making setup disappear.
  • vynl playback, playlists, and the small details that make a TUI feel physical.
  • grimmoire story, prologue, and a renderer that keeps getting more expressive.