Familiar Syntax
Karly uses curly-brace blocks, semicolon-terminated statements and familiar control structures while introducing its own keywords and semantics.
Karly Programming Language • .ky
Code Freely. Think Differently.
A dynamic, multi-paradigm programming language built for learning, experimentation, prototyping and the future.
pointer.ky
Overview
More than a language.
Karly brings together the familiar structure of curly-brace languages with the flexibility of dynamic execution. Its own lexer, recursive-descent parser and tree-walking interpreter make it a compact, inspectable example of how a programming language works from source code to execution.
Designed with education, experimentation and prototyping in mind, Karly lets programmers work with familiar programming concepts while exploring a different execution model.
- Typing
- Dynamic
- Paradigms
- Multi
- Extension
- .ky
- Intellisense
- Context-sensitive
Execution pipeline — internal working
Front-end drivers
Karly
CLI runner + REPL
karly_ide.py
Multi-tab IDE (compile / build / run)
Support components
Symbol Table
Environment / Box (scope chain)
Runtime Object Model
KarlyClass / KarlyObject / Pointer
Error Handling
LexError / ParseError / KarlyRuntimeError / KarlyThrow
Karly Source (.ky)
[program.ky]
Lexical Analysis
lexer.py :: Lexer.tokenize() — source text → token stream
Token Stream
[Token(type, value, line, col), …]
Syntax Analysis
parser.py :: Parser.parse_program() — recursive-descent + precedence climbing
Abstract Syntax Tree (AST)
= Parse Tree (ast_nodes)
Synthesis / Execution
interpreter.py :: Interpreter.run() — tree-walking eval_* / exec_* dispatch (semantic analysis + interpretation fused)
Program Behavior / Output
console text, GUI windows, files, network
Pluggable runtime libraries
Built-in Functions
show, len, range, to_inte, …
karly_gui.py
Tkinter GUI builtins + events
karly_stdlib
random / os / sys / pathlib / requests via include
Features
Built with purpose.
Multi-Paradigm
Write OOP, OBP, POP, SP, FOP and MP programs in one language — object-oriented, object-based, procedural, structured, functional and modular paradigms together.
Dynamic Runtime
Types document intent, while runtime values carry their own type. No separate compilation step is required for normal execution.
Strict Equality
Use = = = when both value and runtime type must match.
Exception Handling
Handle failures gracefully with try, catch and throw.
Memory Concepts
Pointers, address-of, dereferencing and new/del provide the vocabulary of manual memory management while retaining a managed runtime underneath.
Data Structures
Work with arrays, lists, tuples, dictionaries, maps, sets and other common data structures.
Cross-Platform Vision
Karly is designed as a flexible language and tooling ecosystem rather than being tied to a single programming paradigm.
Security
Code isn't the only thing worth protecting.
Cryptographically sealed object members.
Karly introduces two distinctive access specifiers: priblock and problock.
Members declared with priblock or problock become immutable after their first assignment. Every write is recorded as a block in a SHA-256 hash chain associated with the object.
Integrity chain
- BLOCK 01SHA-256
- BLOCK 02SHA-256
- BLOCK 03SHA-256
- VERIFY
Tampering becomes detectable through block_verify().
priblock
Restricted to the object's own methods.
problock
Accessible to subclasses while retaining sealed-state behavior.
This is a hash-chain-based integrity mechanism inside the runtime — not a distributed blockchain network and not a cryptocurrency.
Syntax
Readable by design.
functions_demo.ky
strict.ky
if (5 = = = 5) {
print("Same value and type");
}Note
= = = compares both the value and the runtime type, making intent explicit in dynamically typed code.
IDE
Meet the Karly IDE.
More than an interpreter. A complete desktop environment for writing, running and building Karly programs.
Karly IDE (dark mode) — running a priblock/problock demo with hash-chain verification.
Process
From code to execution.
01
Write
Create a .ky program.
02
Parse
Karly tokenizes and parses your source.
03
Interpret
The AST is executed by the runtime.
04
Build
Use the IDE's build workflow to create an executable.
Why Karly
Why build another language?
Because understanding programming shouldn't stop at using a language.
Karly is also a language-engineering project — a compact environment where learners and developers can explore lexical analysis, parsing, runtime semantics, object-oriented programming, security concepts and developer tooling in one ecosystem.
LEARN
Understand how languages actually work.
BUILD
Create scripts, utilities, experiments and applications.
EXPLORE
Experiment with language design and new programming concepts.
Roadmap
Where Karly goes next.
Planned and exploratory directions. These are not yet implemented.
- 01
Expanded Libraries
Graphics, AI/ML and additional application-development libraries.
- 02
Unified Memory Optimization
Explore unified-memory-aware execution for large workloads.
- 03
Context-Aware Coding
Real-time error detection and intelligent corrective suggestions.
- 04
Generics
More adaptive generic programming capabilities.
- 05
Quantum Computing
Explore future integrations with quantum programming ecosystems.
Ready to write Karly?
Download the Karly IDE and start building.
Karly
Latest Desktop Release · 8.7 MB
Windows
.ky / Executable
Download Karly for Windows
Windows desktop build
Karly / People behind the project
Built by people who love technology.
Meet the people behind Karly, or get in touch to explore collaboration.