Programming languages have long followed similar patterns, with English keywords shaping how developers think and write code around the world. But what if a language broke that mould entirely by embracing one of the most logical writing systems ever created? Enter Han, a fresh project that turns Korean Hangul into the foundation for real, functional code.
Han stands out as a statically typed, compiled language where every core keyword comes straight from Korean. Built entirely in Rust, it delivers both speed through native binaries and convenience with an interpreter. The result is a tool that feels native to Korean speakers while offering the performance and safety Rust programmers have come to expect. This is not just a novelty project or a simple translator for existing syntax. Han reimagines programming from the ground up, using Hangul as a first-class citizen rather than an afterthought.
The creator, Junhyuk Lee, shared the repository on GitHub under the handle xodn348, and it quickly caught attention for its clean approach and practical features. Developers who have followed the project note how it respects the elegance of Hangul while delivering modern language capabilities. Whether you code professionally in Korea or simply appreciate thoughtful language design, Han invites a new way to express logic.
At its core, Han compiles down to LLVM intermediate representation before producing native executables. That path ensures solid performance across platforms. For quicker testing, the built-in tree-walking interpreter lets you run scripts instantly without any extra compilation step. You also get a full REPL for experimentation and an LSP server that brings hover documentation and autocompletion straight into your editor of choice.
The type system keeps things straightforward with five primitive types: 정수 for integers, 실수 for floating-point numbers, 문자열 for strings, 불 for booleans, and 없음 for void. Arrays support standard indexing plus convenient negative indices, along with built-in methods such as 추가 for append, 삭제 for remove, 정렬 for sort, and 역순 for reverse. Structs allow you to define custom data types with field access and implementation blocks, much like you would expect in a modern language.
Closures capture their environment cleanly, pattern matching handles control flow with elegance, and error handling uses a try-catch style construct marked as 시도 and 실패. File operations come built in through functions like 파일 읽기, 파일 쓰기, 파일 추가, and 파일 존재. String formatting supports both positional and named placeholders, while a rich set of string methods covers splitting, searching, replacing, and case conversion.
Modules load through a simple 가져오기 statement, generics follow a clean syntax, and built-in math functions handle square roots, absolute values, powers, and type conversions. Taken together, these pieces create a surprisingly complete toolkit for everyday programming tasks.
One of the most striking aspects is how naturally Korean identifiers fit into the language. You can name variables, functions, and structs entirely in Hangul without any awkward transliteration. This choice opens the door for code that reads like natural Korean prose while still following strict typing rules. For teams working primarily in Korean environments, the benefit is immediate: clearer communication between code and documentation, fewer translation headaches, and a stronger sense of ownership over the codebase.
Installation starts with the GitHub repository. After cloning or downloading the source, you build the toolchain using standard Rust commands. Once compiled, the binary appears as hgl and supports several subcommands. The interpreter mode runs scripts on the spot, the REPL offers an interactive playground, and the LSP mode integrates with popular editors. No complex setup or external dependencies beyond a working Rust installation stand in the way.
A basic example shows just how approachable the syntax feels. Create a file called hello.hgl and add a single line:
출력(“안녕하세요, 세계!”)
Running it with hgl interpret hello.hgl prints the greeting instantly. Switching to the REPL with hgl repl lets you type the same command live and see the output right away. These quick feedback loops make learning and prototyping efficient.
To see Han handle more substantial work, consider a word counter program. The code reads a string, splits it into words, tracks frequencies, and prints the results. It uses loops, conditionals, and array methods entirely in Korean keywords. The logic flows clearly even if you have never seen the language before, because the structure mirrors familiar patterns while the vocabulary stays local.
Here is the full example:
변수 텍스트 = “hello world hello han world hello”
변수 단어들 = 텍스트.분리(” “)
변수 단어목록 = []
변수 개수목록 = []
반복 변수 i = 0; i < 단어들.길이(); i += 1 {
변수 찾음 = 거짓
반복 변수 j = 0; j < 단어 목록.길이(); j += 1 {
만약 단어목록[j] == 단어들[i] {
개수목록[j] = 개수목록[j] + 1
찾음 = 참
}
}
만약 찾음 == 거짓 {
단어목록.추가(단어들[i])
개수목록.추가(1)
}
}
반복 변수 i = 0; i < 단어 목록.길이(); i += 1 {
출력(형식(“{0}: {1}”, 단어목록[i], 개수목록[i]))
}
When executed, it correctly tallies each unique word and displays the counts. The method chaining and array operations feel concise, and the Korean terms keep the intent readable for native speakers.
Another practical demonstration is a simple string calculator. It parses a basic expression, applies the correct operator, and handles division by zero safely. Pattern matching keeps the operator logic organised, while error messages appear in Korean. The entire function remains under fifty lines yet performs real arithmetic work.
Structs shine in a todo list example. You define a custom type for tasks, build methods to add and mark items complete, and display the list with checkmarks. Field access and method calls follow intuitive patterns, and the code reads almost like a Korean sentence outline. This style of development can reduce the mental overhead of switching between natural language and code syntax.
File handling receives similar attention. One example attempts to read a file, count its lines, and gracefully catch any errors. The try-catch block keeps exceptions contained, and string splitting turns the content into a usable array. These small utilities prove that Han handles everyday I/O tasks without friction.
Beyond the syntax, the Rust Foundation brings tangible advantages. Memory safety, thread safety, and fast execution come built in. The compiler toolchain benefits from Rust’s own ecosystem, which translates to fewer bugs in the language implementation itself. LLVM backend support opens future paths to optimisation and cross-compilation. For developers who value reliability, this choice of implementation language adds confidence that Han will remain stable as it grows.
Han also addresses a broader conversation about accessibility in technology. Programming has historically favoured English, creating barriers for non-native speakers. By offering full Korean keyword support, Han lowers that barrier without sacrificing power. Students learning to code in Korean schools or professionals documenting projects for local teams gain a more inclusive environment. At the same time, the language stays compatible with global standards through its type system and compilation model.
Community interest has grown since the repository appeared. Early testers have experimented with generics, closures, and module imports, reporting smooth experiences once the toolchain is set up. The LSP integration means popular editors can provide intelligent help right away. These details matter when evaluating a new language, because developer experience often determines adoption.
Looking ahead, the project shows clear potential for expansion. Additional standard library modules, more advanced data structures, or even foreign function interfaces could broaden its reach. The current feature set already covers a surprising amount of ground for a young language. Its focus on clarity and cultural relevance sets it apart from purely academic experiments.
If you work with Korean text frequently or simply enjoy exploring alternative language designs, Han deserves a close look. The combination of familiar semantics and native vocabulary creates a refreshing coding experience. Whether you compile to a fast binary or run scripts interactively, the tools stay consistent and approachable.
The repository lives at https://github.com/xodn348/han. You can clone it, build the toolchain, and start writing your first Hangul-powered program within minutes. For anyone curious about the intersection of language, culture, and code, this project offers a compelling demonstration of what happens when those worlds align.
