Version 0.8 · Made in Hyderabad

Code that reads
the way you think.

INK is a small, safe, compiled programming language. Simple enough for a first-time programmer, fast as native code, and memory-safe by default.

Memory-safe Native speed Built in x86-64 Assembly
hello.in
show "Namaste, India!"
Output
Namaste, India!

Real INK programs and their output — pick one and press Run. Download INK to write your own.

Download

Get INK — free & open source

INK is MIT-licensed and free forever. Download the latest release, build it with one command, and write your first program in minutes.

Or with git:  git clone https://github.com/uGeorgeFernandez/ink

What's inside

  • The INK compiler — lexer, parser, code generator
  • 8 example programs to learn from
  • The Language Guide & Words Reference
  • build.sh and ink.sh — build and run

Requirements

Linux on x86-64 with nasm and clang. On Windows, use WSL. Full steps in Get started.

Why INK

The ease of Python. The speed of native code. None of C's danger.

INK is built around one idea: a program should read like the instructions a person would naturally give.

Reads clearly

show instead of print, let instead of var, text instead of str. Words a beginner can guess.

Memory-safe

Reading past the end of a list stops with a clear error instead of silently corrupting memory, the mistake behind most security bugs in C.

Type-checked

Mistakes like subtracting a number from text are caught before your program runs, with a plain-English message.

Compiled

INK programs become real native executables through LLVM. No interpreter, no virtual machine, no waiting.

Small

The whole language fits on one page. A small language is one you can hold in your head.

Honest words

Where older languages chose an awkward word, INK chose a clear one.

Everywhere else, INK keeps the familiar word: if, for, while, return. Changing a good word only to look different would be its own mistake.

print→shownothing is printed on paper today
var→letreads like a sentence
str→textthe honest word for words
int→numa number, said simply
def→fnshort for function
while(true)→loopone word for "repeat forever"
array→listwhat people actually say

Would someone who has never programmed guess what it means? If yes, it belongs in INK.

Under the hood

A compiler written from scratch

Every stage of INK's compiler is hand-written in x86-64 Assembly. It owes its foundation to no other programming language.

INPUT

Your program

hello.in

STAGE 1

Lexer

Breaks code into tokens (words)

STAGE 2

Parser

Builds a syntax tree and checks types

STAGE 3

Codegen

Turns the tree into LLVM code

OUTPUT

Native binary

Compiled by clang

Stages marked in saffron are 100% x86-64 Assembly: over 9,500 lines of hand-written code.

Examples

See INK in action

Eight small programs from the repository's examples/ folder, each with its real output.

01_hello.in
show "Hello from INK!"
show "Jai Hind!"
Output
Hello from INK!
Jai Hind!

show puts anything on the screen: text or numbers.

02_variables.in
let name = "George"
let age = 30
show "Name: " + name
show "Age: " + age
Output
Name: George
Age: 30

let stores a value. Adding a number to text turns it into text automatically.

03_decisions.in
let marks = 75
if marks > 90 {
    show "Grade A"
} else if marks > 60 {
    show "Grade B"
} else {
    show "Fail"
}
Output
Grade B

if, else if and else read exactly like plain English.

04_loops.in
for i in 0..5 {
    show i
}
Output
0
1
2
3
4

The range 0..5 counts up to, but not including, 5.

05_functions.in
fn add(a: num, b: num) -> num {
    return a + b
}
show add(5, 3)
Output
8

fn defines a function. -> reads as "gives back".

06_lists.in
let scores = [10, 20, 30, 40]
show len(scores)
show sum(scores)
show scores[0]
Output
4
100
10

Lists hold values in order. Positions start at 0, and len and sum are built in.

07_maps.in
let city = {"George": "Hyderabad", "Priya": "Delhi"}
show city["George"]
show "Priya lives in " + city["Priya"]
Output
Hyderabad
Priya lives in Delhi

Maps look up a value by name instead of by position.

08_biggest.in
fn biggest(xs: list) -> num {
    let best = xs[0]
    let i = 1
    while i < len(xs) {
        best = max(best, xs[i])
        i = i + 1
    }
    return best
}
let data = [3, 9, 2, 15, 7]
show biggest(data)
Output
15

A real little program: functions, lists, a while loop and the built-in max.

Compare

INK vs Python, PHP, .NET and Node.js

Choosing your first language? Here is the short version. The full page compares features, speed, jobs, ease of learning and real code, side by side.

LanguageEase of learningBest for
INKVery easyLearning to program
PythonVery easyAI, data, automation
PHPEasyWebsites, WordPress
C# / .NETModerateEnterprise apps
Node.jsModerateWeb servers, APIs

See the full comparison

Same program, five languages: say "Namaste"

INKshow "Namaste!"
Pythonprint("Namaste!")
PHP<?php echo "Namaste!";
C#Console.WriteLine("Namaste!");
Node.jsconsole.log("Namaste!");
What you can build

Great for learning and small programs

INK is young, and honest about it. Today it shines at exactly the things a new programmer starts with.

Your first programs

Variables, loops, functions, lists and maps — the core ideas of programming, with words a beginner can guess.

Teaching in the classroom

Small enough to teach in one lesson. show, let, num — plain words school students read at a glance.

Practice & exercises

Perfect for problem-solving drills — grades, the biggest number, sums and averages — where clear logic matters most.

Little command-line tools

Read what the user types, do the maths, and read or write files — small utilities that run as fast native programs.

Bigger things — modules, a standard library, graphics, the web — are on the roadmap. INK is built to grow.

Get started

Run your first INK program in minutes

Install the tools

INK needs NASM and LLVM/Clang. On Ubuntu or Debian:

sudo apt-get install nasm llvm clang

Get INK and build it

Clone the repository and build the compiler:

git clone https://github.com/uGeorgeFernandez/ink
cd ink
./build.sh

Write and run

Save a file called first.in, then run it:

show "Hello from INK!"
./ink.sh first.in

Requires Linux on x86-64. On Windows, use WSL.

Download INK (.zip)

Free & open source (MIT). Prefer the terminal? Use the git clone above.

Your feedback

Tried INK? Tell us what you think

We want INK to be the easiest first language to learn, especially for students. Your feedback decides what we build next.

What's new

Latest updates

Release

INK v0.8 — the working compiler

The full pipeline — lexer, parser and code generator, all hand-written in x86-64 Assembly — compiles real programs to native binaries through LLVM.

Language

The number type is now num

We renamed int to num — the plain word for a number, friendlier for first-time and school programmers. Old int code still works.

Website

A new home with a live playground

Try INK in the browser, compare it with Python, PHP, C# and Node.js word for word, and download it in one click.

Status & roadmap

An honest working prototype

INK compiles and runs real programs today. Building operating systems, games or large applications is a long-term goal, and we say so plainly.

v0.8 working60+ test programs

Roadmap

  • ✓Lexer, parser, code generator
  • ✓Variables, functions, recursion
  • ✓Text, lists and maps
  • ✓Type checking and memory safety
  • ✓Keyboard input and file I/O
  • Comments, and line numbers in errors
  • Modules: import and multiple files
  • Bigger standard library (text tools)
  • A large test suite
  • Script Mode vs System Mode

Known limitations

  • Memory is not freed yet, so very long-running programs use more and more memory.
  • read_file reads up to 64 KB.
  • Error messages don't show line numbers yet.
  • No module or import system yet: one program, one file.

Help INK grow

The most valuable contribution is a real program written in INK. Bug reports and ideas are welcome on GitHub.

Open an issue

Write the Future.

Learn the whole language in an afternoon, from your first show to maps and files.