Skip to content
/ NLPL Public

A general-purpose programming language that reads like English

1 star 0 forks Branches Tags Activity
Star
Notifications You must be signed in to change notification settings

Zajfan/NLPL

BranchesTags

Repository files navigation

NLPL - Natural Language Programming Language

A general-purpose programming language that reads like English

Status Python License

What is NLPL?

NLPL is a production-ready programming language designed to be:

  • Natural: Reads like English prose (set x to 10, if age is greater than 18)
  • Powerful: Full OOP, generics, pattern matching, inline assembly
  • Universal: One language for OS kernels, web apps, system tools, and everything between
  • Low-level capable: Direct memory access, FFI, inline x86_64 assembly
  • Type-safe: Optional strong typing with inference and generics
# Hello, World in NLPL
print text "Hello, world!"

# Natural language syntax
function greet with name as String
  if name is not empty
    print text "Hello, " plus name plus "!"
  else
    print text "Hello, stranger!"
  end
end

call greet with "Alice"

Key Features

✅ Fully Implemented (February 2026)

  • Rc Smart Pointers - Reference counting with automatic cleanup (NEW!)
  • LLVM Compiler - Native code generation, 1.80-2.52x C performance (NEW!)
  • Pattern Matching - Rust-style match expressions with guards
  • Structs & Unions - C-compatible memory layout
  • Inline Assembly - x86_64 assembly for system programming
  • FFI - Call any C library (with variadic function support!)
  • Generics - Full generic types with constraints
  • Type Inference - Automatic type deduction
  • 62 stdlib modules - Comprehensive standard library
  • Classes & Interfaces - Full OOP support
  • Memory Management - Direct memory control (malloc/free/pointers)
  • Error Handling - Try/catch with custom exceptions
  • Module System - Import/export with namespaces

Recent Additions (Feb 2-8, 2026)

  • ✨ Generic types fully working - Parameterless method calls fixed (Feb 8)
  • ✨ Rc smart pointers - Reference counting with automatic memory management (Feb 6)
  • ✨ LLVM compiler backend - Native code generation, 1.80-2.52x C performance (Feb 6)
  • ✨ Pattern matching interpreter - Full match/case/guard support (Feb 2-3)
  • ✨ Inline assembly - Direct x86_64 instruction embedding (Feb 2-3)
  • ✨ FFI variadic functions - Call printf, fprintf, scanf (Feb 2-3)
  • ✨ Comprehensive documentation - 8,000+ lines of guides

Quick Start

Installation

git clone https://github.com/Zajfan/NLPL.git
cd NLPL
python src/main.py --version

Requirements: Python 3.8+

Your First Program

Create hello.nlpl:

print text "Hello, NLPL!"

Run it:

python src/main.py hello.nlpl

See the Quick Start Guide for a 5-minute tutorial!

Language Showcase

Variables & Functions

# Variables with natural syntax
set name to "Alice"
set age to 25
set scores to [95, 87, 92]

# Functions with type annotations
function calculate_average with numbers as List of Float returns Float
  if numbers is empty
    return 0.0
  end
  
  set total to 0.0
  for each num in numbers
    set total to total plus num
  end
  
  return total divided by (length of numbers)
end

set avg to calculate_average with [95.0, 87.0, 92.0]
print text "Average: " plus (avg to_string)

Pattern Matching NEW!

function classify with value as Integer returns String
  match value with
    case 0 then return "zero"
    case n if n is less than 0 then return "negative"
    case n if n is less than 10 then return "small positive"
    case n then return "large positive"
  end
end

print text classify with -5    # "negative"
print text classify with 3     # "small positive"
print text classify with 100   # "large positive"

Generics NEW!

# Generic container with type parameters
class Box<T>
  property value as T
  
  method get_value returns T
    return this.value
  end method
  
  method set_value with v as T
    set this.value to v
  end method
end class

# Create specialized instances
set int_box to new Box<Integer>
set int_box.value to 42
print text call int_box.get_value  # 42

call int_box.set_value with 100
print text call int_box.get_value  # 100

# Generic pair class
class Pair<K, V>
  property key as K
  property val as V
  
  method get_key returns K
    return this.key
  end method
  
  method get_value returns V
    return this.val
  end method
end class

set coord to new Pair<Integer, Integer>
set coord.key to 10
set coord.val to 20
print text call coord.get_key    # 10
print text call coord.get_value  # 20

Object-Oriented Programming

class BankAccount
  private balance as Float
  
  function init with self, initial_balance as Float
    if initial_balance is less than 0
      raise error "Initial balance cannot be negative"
    end
    set self.balance to initial_balance
  end
  
  function deposit with self, amount as Float
    if amount is greater than 0
      set self.balance to self.balance plus amount
    end
  end
  
  function withdraw with self, amount as Float returns Boolean
    if amount is greater than self.balance
      return false
    end
    set self.balance to self.balance minus amount
    return true
  end
  
  function get_balance with self returns Float
    return self.balance
  end
end

set account to new BankAccount with 1000.0
call account.deposit with 500.0
if account.withdraw with 200.0
  print text "Withdrawal successful"
end
print text "Balance: " plus (account.get_balance to_string)

Structs for System Programming

# C-compatible struct
struct Point
  x as Integer
  y as Integer
end

set p to new Point
set p.x to 10
set p.y to 20

# Use with FFI
extern function print_point with pt as Pointer to Point
call print_point with (address of p)

Inline Assembly

function fast_multiply with a as Integer, b as Integer returns Integer
  asm "
    mov rax, rdi     ; First argument
    imul rax, rsi    ; Multiply
    ret
  "
end

set result to fast_multiply with 6, 7  # 42

FFI - Call C Libraries

# Call printf from C standard library
extern function printf with format as String, ... returns Integer

call printf with "Hello from C!\n"
call printf with "Number: %d, Float: %.2f\n", 42, 3.14

Smart Pointers NEW!

# Reference-counted smart pointers
function create_shared_data returns Integer
  set x to Rc of Integer with 42
  set y to Arc of Integer with 100  # Thread-safe variant
  
  print text "Rc value: " plus (dereference x to_string)
  print text "Arc value: " plus (dereference y to_string)
  
  # Automatic cleanup when function returns
  return 0
end

Documentation

Complete documentation available in docs/:

Getting Started

Core Concepts

Reference

Examples

Standard Library

62 production-ready modules:

Core

  • math - Mathematical operations (sin, cos, sqrt, pow, ...)
  • string - String manipulation (upper, split, trim, ...)
  • io - File I/O and console operations
  • collections - Vec, HashMap, Set data structures
  • system - OS interactions and process management
  • network - HTTP, sockets, URLs

Graphics & Rendering

  • vulkan - Vulkan API for GPU programming
  • graphics - 2D/3D primitives
  • rendering - Rendering pipeline
  • shaders - Shader compilation

Data Formats

  • json_utils, csv_utils, xml_utils - Data parsing
  • compression - gzip, zip, bzip2
  • serialization - Object serialization

System Programming

  • asm - Inline assembly utilities
  • ffi - Foreign function interface
  • filesystem - File operations
  • subprocess_utils - Process spawning
  • threading_utils - Multithreading

Utilities

  • datetime_utils, uuid_utils, validation
  • logging_utils, testing, regex
  • option_result - Rust-style Option/Result<T,E>

See full stdlib documentation →

Examples

Explore 24+ Example Programs

# Basic concepts
python src/main.py examples/01_basic_concepts.nlpl

# Functions and scope
python src/main.py examples/02_functions.nlpl

# Object-oriented programming
python src/main.py examples/04_classes.nlpl

# Pattern matching (NEW!)
python src/main.py examples/15_pattern_matching.nlpl

# Structs and unions (LOW-LEVEL)
python src/main.py examples/24_struct_and_union.nlpl

All examples include comments and explanations!

Project Status

v1.0 Release: Q2 2026

Current Status: 95% Complete

✅ Completed:

  • Lexer, parser, AST (15,000+ lines)
  • Full interpreter with type checking
  • LLVM compiler backend (10,171 lines, Feb 6 2026)
  • Rc smart pointers with automatic memory management (Feb 6 2026)
  • Pattern matching (Feb 2-3 2026)
  • Inline assembly (Feb 2-3 2026)
  • FFI with variadic functions (Feb 2-3 2026)
  • Struct/Union types (verified complete)
  • 62 stdlib modules
  • Comprehensive documentation (8,000+ lines)

⏳ Remaining:

  • LSP server testing and documentation
  • Performance optimizations
  • Package manager (post-1.0)

See detailed status →

Command-Line Usage

# Run with interpreter (default)
python src/main.py program.nlpl

# Compile to native code with LLVM (1.80-2.52x faster)
python dev_tools/scripts/compile.py program.nlpl
./build/program

# Debug mode (show tokens and AST)
python src/main.py program.nlpl --debug

# Disable type checking
python src/main.py program.nlpl --no-type-check

# Benchmark performance
python benchmarks/benchmark_performance.py

Architecture

                    ┌─ Interpreter → Runtime (Direct execution)
                    │
Source (.nlpl) → Lexer → Parser → AST ─┤
                                   │    │
                                   ↓    └─ LLVM IR Generator → Native Code (1.80-2.52x faster)
                              Type Checker (optional)

Components:

  • Lexer (1,060 lines) - Tokenizes natural language syntax
  • Parser (7,469 lines) - Recursive descent parser
  • AST (1,030 lines) - 80+ node types
  • Interpreter (2,658 lines) - Direct execution engine
  • LLVM Backend (10,171 lines) - Native code generation
  • Type Checker (1,541 lines) - Optional type validation
  • Runtime (400+ lines) - Memory management, concurrency
  • Rc Runtime (430 lines C) - Reference counting library

Total Core: ~25,000 lines of production code

Contributing

NLPL welcomes contributions! See CONTRIBUTING.md for guidelines.

High-impact areas:

  • Performance benchmarking
  • LSP server testing
  • Example programs
  • Bug reports and fixes

Design Philosophy

NO SHORTCUTS. NO COMPROMISES.

NLPL is a full programming language, not a prototype:

  • Complete implementations - No placeholders or TODOs
  • Production-ready code - Robust error handling
  • Real features - No simplified versions
  • Proper architecture - No workarounds or hacks

Every feature is built to compete with established languages like C++, Python, and Rust.

Comparison with Other Languages

Feature NLPL Python C++ Rust
Natural syntax ✅ ❌ ❌ ❌
Smart pointers (Rc) ✅ ❌ ✅ ✅
Native compilation ✅ ❌ ✅ ✅
Inline assembly ✅ ❌ ✅ ✅
Pattern matching ✅ ✅ (3.10+) ❌ ✅
Memory control ✅ ❌ ✅ ✅
Generics ✅ ❌ (runtime only) ✅ ✅
FFI ✅ ✅ ✅ ✅
Easy to read ✅ ✅ ❌ ❌
Type safety ✅ ⚠️ (optional) ⚠️ ✅
OS development ✅ ❌ ✅ ✅
Performance 1.8-2.5x C ~50x slower 1.0x (baseline) 0.9-1.1x C

NLPL combines:

  • Python's readability
  • C++'s low-level power
  • Rust's safety features
  • Its own natural language syntax

Roadmap

v1.0 (Q2 2026) - ALMOST THERE!

  • ✅ Core language features (COMPLETE)
  • ✅ Pattern matching (COMPLETE - Feb 2026)
  • ✅ Inline assembly (COMPLETE - Feb 2026)
  • ✅ FFI with variadic functions (COMPLETE - Feb 2026)
  • ✅ Comprehensive documentation (COMPLETE - Feb 2026)
  • ⏳ LSP testing and docs
  • ⏳ Performance optimization

Post-v1.0

  • Package manager (install, publish, dependencies)
  • Enhanced debugger (breakpoints, step-through)
  • JIT compilation
  • LLVM compiler backend optimization
  • Self-hosting (NLPL compiler written in NLPL)
  • Web compilation (WASM target)

See full roadmap →

Community

License

MIT License - See LICENSE for details.

Credits

Created by: Zajfan
Contributors: See CONTRIBUTORS.md

Special Thanks:

  • Everyone who provided feedback and suggestions
  • The open-source community

Quick Links

Summary

NLPL is a production-ready programming language that combines:

✅ Natural language syntax for readability
✅ Low-level power (assembly, FFI, memory control)
✅ Modern features (pattern matching, generics, type inference)
✅ Comprehensive stdlib (62 modules)
✅ Full OOP support
✅ System programming capabilities

Start coding today! See QUICKSTART.md to get started in 5 minutes.

Version 1.0 coming Q2 2026 - Join us in building the future of programming languages!

Last Updated: February 9, 2026

About

A general-purpose programming language that reads like English

Topics

language programming-language programming natural-language general-purpose natural general-purpose-language

Resources

Readme
Activity

Stars

1 star

Watchers

0 watching

Forks

0 forks
Report repository

Releases

2 tags

Packages

No packages published

Languages