README.md

June 26, 2026 · View on GitHub

Write computer programs in Kinyarwanda!

Getting Started . Why Kin? . VS Code support . Show us what you did!

GitHub . GitHub last commit . Version . Stars . Issues

Description

Kin is a straightforward programming language created with the purpose of aiding Rwandans to write computer programs in their native language Kinyarwanda.

:information_source: Contributors: Please see our ARCHITECTURE.md for a deep dive into Kin's architecture, design, and execution flow before contributing!

Installation

You can install Kin in one of two ways:

Option 1: npm (requires Node.js)

If you already have Node.js installed:

npm i -g @kin-lang/kin

Then run Kin from any terminal:

kin --version
kin repl
kin run path/to/program.kin

Option 2: Standalone Windows executable (no Node.js required)

If you are on Windows and do not have Node.js installed, download the pre-built executable from the latest GitHub Release:

Go to Releases
Download kin-win-x64.exe
Place it somewhere convenient (for example C:\kin\)
Optionally add that folder to your system PATH
Run it from Command Prompt or PowerShell:

kin-win-x64.exe --version
kin-win-x64.exe repl
kin-win-x64.exe run path\to\program.kin

You can rename kin-win-x64.exe to kin.exe for shorter commands.

This executable is built with pkg and bundles the Kin runtime so you do not need Node.js separately.

Building the executable yourself

Maintainers and contributors can build the Windows .exe locally:

npm install
npm run build:exe

The output is written to release/kin-win-x64.exe. To build for multiple platforms:

npm run build:exe:all

Why Kin?

Goal: Kin's main objective is to make learning programming more accessible by using Kinyarwanda, the native language for Rwandans.
Focus: It's a straightforward language, prioritizing easy of use over complex features. This makes it suitable for education purpose.
Use Cases: While Kin is great for learning the fundamentals, it's suitability for large-scale software development isn't guaranteed.

What does it look like

This is implementation of linear search:

reka arr = [45, 56, 334, 78, 34, 78, 23, 90]

reka i = 0

reka key = 23

subiramo_niba(i < KIN_URUTONDE.ingano(arr)) {
  niba (arr[i] == key) {
    tangaza_amakuru("Key ", key, " is on ", i + 1, " position")
  }

  i = i + 1
}

Hello <name> !

reka name = injiza_amakuru("Enter your name: ")
tangaza_amakuru("Hello ", name, "!")

Executing system commands
```
sisitemu("sudo shutdown now")
```

Syntax

Though Kin inherited it's syntax and structure from JavaScript, they're completely different when it comes to behavior. Some notable Kin's syntax rules are:

Semicolon:
- A semicolon is required when you declare a variable but you don't assign a value to it.
```
 reka x; # This will work
```
- A semicolon is required when a function returns but there's not expression to return.
```
porogaramu_ntoya main() {
  tanga; # This will work
}
```
  In General a semicolon is used to tell Kin that there's an ommited statement.
White spaces:
- Kin ignores white spaces, that's why multiple lines can be written at the same line ... these codes are equivalens
```
reka x = 5
reka x=5
```

Fun fact!

Multiple statements can be written on the same line.

reka name = injiza_amakuru("Enter your name: ") tangaza_amakuru("Hello ", name, "!")

Nested statements are also supported.

tangaza_amakuru("Hello ", injiza_amakuru("Enter your name: "), "!")