Write computer programs in Kinyarwanda!

Getting Started . Why Kin? . VS Code (highlighting, diagnostics, completions) . Show us what you did!

. . . .

Description

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

ℹ️ 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
kin check 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:

1. Go to Releases
2. Download kin-win-x64.exe
3. Place it somewhere convenient (for example C:\kin\)
4. Optionally add that folder to your system PATH
5. 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.

VS Code

Install the official extension from the Marketplace (search kinlang). It provides syntax highlighting, parser diagnostics, completions, and hover docs for built-ins. Source: kin-lang/vscode-intellisense.

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: urutonde = [45, 56, 334, 78, 34, 78, 23, 90]
  
  reka i: umubare = 0
  
  reka key: umubare = 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: ijambo = injiza_amakuru("Enter your name: ")
  tangaza_amakuru("Hello ", name, "!")
  

• Typed functions and type aliases

  ubwoko Person = { name: ijambo, age: umubare }
  
  porogaramu_ntoya greet(p: Person): ijambo {
    tanga "Muraho " + p.name
  }
  
  reka keza: Person = { name: "Keza", age: 20 }
  tangaza_amakuru(greet(keza))
  

• Multi-file modules (koresha / nka / emerera_gukoresha)

  # methods.kin
  porogaramu_ntoya guteranya(a: umubare, b: umubare): umubare {
    tanga a + b
  }
  emerera_gukoresha { guteranya }
  
  # main.kin
  koresha "./methods.kin" nka math
  tangaza_amakuru(math.guteranya(2, 3))
  

• 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
    

Truthiness

In niba, nanone_niba, and subiramo_niba, values are tested for truthiness:

• false: sibyo, ubusa, and the number 0
• true: everything else (non-zero numbers, non-empty and empty strings, arrays, objects, functions)

String concatenation

+ on two strings concatenates them. A string and a number also concatenate (the number is coerced), so beginners can write "Ufite imyaka " + imyaka.

Arrays

Array literals produce a real array value (urutonde). Index out of range raises an error.

reka arr = [10, 20, 30]
tangaza_amakuru(arr[0])              # 10
tangaza_amakuru(KIN_URUTONDE.ingano(arr))
tangaza_amakuru(arr.ingano())          # method form
tangaza_amakuru(KIN_URUTONDE.ifite(arr, 20))  # nibyo

Checking a file without running it

kin check path/to/program.kin

Reports all parse diagnostics (with line, column, and a caret) and exits non-zero when there are errors. Useful for teachers and CI.

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: "), "!")
  

---

Contributing

We still have a long way to go with Kin, we're calling for your contributions! Contributions are welcomed, refer to Contiributing.md for futher info.

Maintainers

This language is maintained by @pacifiquem.

License

This project is under MIT License.

PACIFIQUE Murangwa - Author