DEV Community: Ankit bishnoi

I built my own programming language at 19 — Akro (runs in the browser, no install)

Ankit bishnoi — Tue, 12 May 2026 12:22:20 +0000

Who am I?

I'm Ankit Bishnoi, 19 years old from India.

Skills: JavaScript, TypeScript, React, HTML/CSS, Python, MongoDB, SQL, Ethical Hacking, Social Media.

GitHub: @ankitkhileryy

What I built

Akro — a minimal programming language that runs entirely in the browser.

The name comes from my initials "AK". Personal name, universal language.

No install needed → try it now: akro-lang.dev/playground

What it looks like


akro
fn main {
  name := "World"
  say "Hello, {name}!"

  nums := [1, 2, 3, 4, 5]
  total := reduce(nums, fn(a, b) { return a + b }, 0)
  say "Sum = {total}"

  grade := match 87 {
    case 90..100 { "A" }
    case 80..89  { "B" }
    case _       { "C or below" }
  }
  say "Grade: {grade}"
}

I wrote a programming language that runs in the browser — introducing Akro

Ankit bishnoi — Tue, 12 May 2026 12:17:20 +0000

What is Akro?

Akro is a minimal programming language with a browser-based interpreter.

No install needed — you can run Akro code right now at akro-lang.dev/playground.

The name "Akro" starts with "AK" — the initials of the developer @ankitkhileryy.

The name is personal, the language is for everyone.

Why I built it

I wanted a language that combined three things I liked from existing languages:

Python — clean, readable syntax
Go — fast compilation, simple structure
JavaScript — web-native, runs everywhere

None of them alone felt right. So I built Akro.

What it looks like


akro
fn fibonacci(n) {
  if n <= 1 { return n }
  return fibonacci(n - 1) + fibonacci(n - 2)
}

fn main {
  for i in 0..10 {
    say "{i}: {fibonacci(i)}"
  }
}
Output:

0: 0
1: 1
2: 1
3: 2
4: 3
5: 5
6: 8
7: 13
8: 21
9: 34
Key design decisions
:= for variable declaration
name := "Akro"
count := 42
is_fast := true
No var, no let, no const noise. Inspired by Go.

No semicolons, no type annotations required
fn greet(name) {
  return "Hello, {name}!"
}
Types are inferred. You only annotate when you want to.

String interpolation with {expr}
x := 10
say "Double is {x * 2}"   // Double is 20
Supports full expressions, not just variable names.

Pattern matching
score := 87

grade := match score {
  case 90..100 { "A" }
  case 80..89  { "B" }
  case 70..79  { "C" }
  case _       { "F" }
}

say "Grade: {grade}"
Error handling
fn divide(a, b) {
  if b == 0 { throw "Division by zero" }
  return a / b
}

try {
  say divide(10, 2)
  say divide(5, 0)
} catch err {
  say "Error: {err}"
}
First-class functions & closures
nums := [1, 2, 3, 4, 5]
doubled := map(nums, fn(x) { return x * 2 })
say doubled   // [2, 4, 6, 8, 10]
Current status
v0.1.0-beta — The interpreter is written in TypeScript and runs entirely in the browser.

It handles:

Variables, constants, mutation
Functions, closures, recursion
Loops (for, while, loop)
Arrays, maps, structs
Pattern matching
Error handling (try/catch)
String interpolation
Built-ins: map, filter, reduce, sort, len, range, and 40+ more
Native compilation is on the roadmap for v0.3.0.

Roadmap
Version Feature
v0.1.0 ✅  Beta — browser interpreter
v0.2.0  Package manager & modules
v0.3.0  Native binary compilation
v0.4.0  VS Code extension & LSP
v1.0.0  Stable release
Try it
▶️ Playground (no install): akro-lang.dev/playground
📖 Docs: akro-lang.dev/docs/introduction
⭐ GitHub: github.com/ankitkhileryy

I Built My Own Programming Language at 19 – Introducing Akro

Ankit bishnoi — Wed, 06 May 2026 07:38:12 +0000

Hi DEV community! I'm Ankit Bishnoi, 19 years old from India, and I just
released my first major open source project — Akro, a programming language
I built from scratch.

Why I built Akro

I was frustrated with existing languages:

Python is simple but slow
Go is fast but verbose
JavaScript is everywhere but messy

So I spent months building Akro to combine the best of all three.

What Akro looks like


akro
fn main {
    name := "World"
    say "Hello, {name}!"

    nums := [1, 2, 3, 4, 5]
    total := reduce(nums, fn(a, b) { return a + b }, 0)
    say "Sum = {total}"

    for i in 0..5 {
        say "i = {i}"
    }
}
Key Features
Type inference — like Rust/Go

x := 10
name := "Akro"
pi := 3.14
String interpolation — supports full expressions

say "Hello, {name}!"
say "1 + 1 = {1 + 1}"
say "Sum = {sum(nums)}"
Pattern matching

match score {
    case n if n >= 90 => say "A grade"
    case n if n >= 80 => say "B grade"
    default           => say "F grade"
}
Transpiles to JavaScript — write Akro, run in browser

akro transpile app.ak
# → app.js (ready for browser)
Error handling

try {
    result := divide(10, 0)
} catch(e) {
    say "Error: {e}"
}
Structs with methods

struct Point {
    x: int
    y: int
}

impl Point {
    fn distance(self) -> float {
        return sqrt(self.x ** 2 + self.y ** 2)
    }
}

p := Point(3, 4)
say p.distance()  // 5.0
How it's built
The interpreter is written in Go:

Hand-written lexer
Recursive descent parser
Tree-walking interpreter
JS transpiler (AST → JavaScript)
40+ built-in functions
Install
npm install -g akro-lang
akro run hello.ak        # Run a file
akro repl                # Interactive shell
akro transpile app.ak    # Convert to JavaScript
akro version             # Show version
Links
GitHub: https://github.com/ankitkhileryy/akro
npm: https://www.npmjs.com/package/akro-lang
This is my first major open source project. I'd love honest feedback — what's missing, what could be better, and what would make you actually use a new language.

Thanks for reading!

— Ankit Bishnoi, 19, India