// ASSEMBLED, NOT INVENTED
K.

K is built from the parts of Python, C++, and Java that are actually pleasant to use — with the friction each one is known for engineered out. One interpreter, one IDE, three platforms.

Get K for your OS ↓ See the syntax
v0.1 · early release
MIT licensed
Windows · macOS · Linux
PYTHON C++ JAVA K .k
// SPEC SHEET

What each part actually fixes

K doesn't borrow syntax for its own sake — each piece is there because it solves a specific, named problem.

01
Python
Slow by default · no true encapsulation · len(x) vs x.method() inconsistency
Same clean indentation syntax, but one consistent thing.method(args) call style, structured so a bytecode VM can be added without changing the language.
02
C++
Manual memory management · header/source split · undefined behavior
No manual memory management, no header files, no UB — errors raise a catchable KError with a line number instead of crashing.
03
Java
Boilerplate main method · verbose type ceremony · checked exceptions
No boilerplate to start a program — top-level code just runs. Types are optional documentation. try / except is one clause.

Read this honestly: K is a real, working tree-walking interpreter today — not yet faster than compiled C++ or the JIT-warmed JVM. What it delivers now is less ceremony than Java, safer defaults than C++, and one consistent method-call syntax. The bytecode VM on the roadmap is the path to "faster than all three."

// SYNTAX

Reads like Python, behaves like a compiled language should

Classes, closures, f-strings, and a for-loop — no imports, no boilerplate, no main().

dog.k
class Dog:
    func init(self, name):
        self.name = name

    func speak(self):
        print(f"{self.name} says Woof")

let d = new Dog("Rex")
d.speak()

let nums = [1, 2, 3, 4, 5]
let total = 0
for n in nums:
    total += n
print(f"sum: {total}")  # -> sum: 15
// DOWNLOAD

Get K running on your machine

v1.0.3 — real, CI-built binaries for all three platforms, straight from the GitHub release.

Windows
K-Setup.exe installs k and K-IDE, adds them to PATH, and associates .k files — built with Inno Setup on tagged releases.
K-Setup.exe · 19.5 MB
Download for Windows ↓
macOS
Standalone k and K-IDE binaries bundling their own interpreter — no local Python required. After downloading, run chmod +x k-macos once to mark it executable.
k-macos · 6.9 MB
Download CLI ↓ Download K-IDE ↓
Linux
Standalone binaries — no local Python required. After downloading, run chmod +x k-linux once to mark it executable.
k-linux · 15.8 MB
Download CLI ↓ Download K-IDE ↓

All builds above are from release v1.0.3, compiled directly from source by GitHub Actions on each platform's own OS. Prefer installing from source instead? git clone https://github.com/NodeX-AR/K.git && cd K && ./install.sh works on macOS/Linux with Python 3.9+.

// LEGEND

What's implemented today

20 passing tests exercise all of it — run python -m unittest discover -s tests -v to see for yourself.

let / const

Bindings, with optional : type annotations kept as documentation.

func name(a, b=1):

Functions, closures, and nested functions.

class Name(Base):

Inheritance, self, init, and new.

if / elif / else

Standard branching, plus while and for x in iterable:.

break / continue / return

Familiar control-flow escapes.

try: / except e:

One clause — no typed exception hierarchy to declare.

f"{expr}"

F-strings, plus ints, floats, true/false/null.

[1,2,3] / {"a":1}

Lists and dicts with indexing, slicing, and built-in methods.

print, len, range …

Core built-ins: str, int, float, bool, type, input, abs, min, max, sum, sorted, round.

// ROADMAP

Honest next steps toward "faster than all three"

Bytecode VM

Compile the AST to a compact instruction set instead of walking the tree — the usual 5–10x win, no language changes.

Real static type checking

Turn the currently-decorative type annotations into an actual checker.

Native / JIT compilation for typed code

The PyPy/Cython playbook: fully-typed functions compile to machine code, untyped code stays dynamic.

Package manager + bigger standard library

Usually where a language's real-world capability actually comes from.