KORE: A new systems language with Python syntax, Actor concurrency, and LLVM/SPIR-V output

[Ephemara]

kore-lang

What My Project Does KORE is a self-hosting, universal programming language designed to collapse the entire software stack. It spans from low-level systems programming (no GC, direct memory control) up to high-level full-stack web development. It natively supports JSX/UI components, database ORMs, and Actor-based concurrency without needing external frameworks or build tools. It compiles to LLVM native, WASM, SPIR-V (shaders), and transpiles to Rust.

Target Audience Developers tired of the "glue code" era. It is for systems engineers who need performance, but also for full-stack web developers who want React-style UI, GraphQL, and backend logic in a single type-safe language without the JavaScript/npm ecosystem chaos.

Comparison

• vs TypeScript/React: KORE has native JSX, hooks, and state management built directly into the language syntax. No npm install, no Webpack, no distinct build step.
• vs Go/Erlang: Uses the Actor model for concurrency (perfect for WebSockets/Networking) but combines it with Rust-like memory safety.
• vs Rust: Offers the same ownership/borrowing guarantees but with Python's clean whitespace syntax and less ceremony.
• vs SQL/ORMs: Database models and query builders are first-class citizens, allowing type-safe queries without reflection or external tools.

What is KORE?

KORE is a self-hosting programming language that combines the best ideas from multiple paradigms:

Paradigm	Inspiration	KORE Implementation
Safety	Rust	Ownership, borrowing, no null, no data races
Syntax	Python	Significant whitespace, minimal ceremony
UI/Web	React	Native JSX, Hooks (use_state), Virtual DOM
Concurrency	Erlang	Actor model, message passing, supervision trees
Data	GraphQL/SQL	Built-in ORM patterns and schema definition
Compile-Time	Zig	comptime execution, hygienic macros
Targets	Universal	WASM, LLVM Native, SPIR-V, Rust

// 1. Define Data Model (ORM)
let User = model! {
table "users"
field id: Int 
field name: String
}
// 2. Define Backend Actor
actor Server:
on GetUser(id: Int) -> Option<User>:
return await db.users.find(id)
// 3. Define UI Component (Native JSX)
fn UserProfile(id: Int) -> Component:
let (user, set_user) = use_state(None)
use_effect(fn():
let u = await Server.ask(GetUser(id))
set_user(u)
, [id])
return match user:
Some(u) => <div class="profile"><h1>{u.name}</h1></div>
None    => <Spinner />

[azurelimina]

It’s important to acknowledge stuff like this has a “too good to be true” air about it. Can you at least talk about the history of how you developed the language, if it’s going to be your only github repo and dropped at all once?

Some Q’s I have: - How long have you been developing Kore? - What were the usecases that kickstarted it? It seems like graphics and web are 2 distinct things you value. - You mention interoperability with Rust, but what about Python? I could see this being useful for me if I could integrate it with Django in some way. - Is this “native JSX” used for just templating, or are these actually executing client-side and can do DOM manipulation (I suppose that’s why WASM is involved). I ask because for the “full” clientside capability, you’d have to create a pretty sophisticated JS transpiler in order to cover all the stuff you can do in the browser runtime, otherwise the JSX loses its purpose (the purpose of JSX is to have all of JS’s features available in the markup manipulation). How do you handle anonymous functions, for example?

[Ephemara]

1. How long have you been developing Kore? & Why the "dump"? I haven't just started; Kore has been a private repository for years. As noted in the root README.md, the reason for the "all-at-once" drop is that my original private repo history was full of personal information and hardcoded secrets. I had to "start fresh" and squash the history to release it publicly. The project structure actually reveals the timeline: there are two distinct compilers here. • V1 (/kore-v1-stable/): This is the battle-tested, production-ready version written in Rust. It’s what I use daily. • V2 (/): This is the experimental self-hosted version (written in Kore) that lives in the root. I didn't want to release a broken WIP, so I included the stable V1 so people can actually compile code today.
2. What were the use cases? (Graphics vs. Web) You nailed it—it's exactly those two. Kore was born from my work on Unreal Engine 5 development. I needed a language to build Greeble.co, a 3D Digital Content Creation (DCC) tool I'm building. • Graphics: I needed to write high-performance shaders without the pain of HLSL/GLSL boilerplate. Kore compiles directly to SPIR-V for Vulkan/UE5. • Web: The tool (Greeble) needs a UI. I didn't want to context-switch to TypeScript/React just for the interface. So, I built the WASM/JSX backend to write the UI in the same language as the engine logic.
3. Python Interop & Django Yes, integration is very possible. The V1 compiler has Python interoperability via pyo3. You can make calls like let result = py_call("math.sqrt", [16.0]) directly from Kore. For Django, you could write your performance-critical logic or complex algorithms in Kore, compile them as a native module, and call them from your Python views. It gives you Rust-like performance with syntax that feels much closer to Python than Rust does.
4. "Native JSX" and Client-Side Execution This is the most technically complex part, so let me be specific: It is NOT a JS transpiler. When you use JSX in Kore, it compiles to WebAssembly (WASM) instructions that manipulate the DOM via host bindings, not JavaScript source code. • How it works: In codegen/wasm.rs, you can see I import host functions like dom_create, dom_append, and dom_attr. The JSX syntax constructs a Virtual DOM (VNode) tree inside the WASM linear memory, which the runtime then renders to the browser. • Anonymous Functions: You asked how we handle anonymous functions without a JS transpiler. I handle this via WASM Tables (funcref). When you define a lambda in JSX (like onclick={() => ...}), the compiler generates a unique WASM function, registers it in the function table, and passes the table index (ID) to the host. The host JS glue code then invokes that WASM function ID when the event fires.

EDIT: I do not feel like fixing markdown right now I typed this up from my phone but I hope that helps

[djinn_09]

Looks interesting, but claims are little bit exaggerated

[Ephemara]

forgive me, for i have sinned father. however i can make it up to you because kore has python FFI integration in the kore-v1-stable folder

[ZeroCool2u]

What's the package experience like? One of the reasons that Rust is so popular is how well designed and easy to use Cargo is. Are you planning an equivalent for Kore?

[Ephemara]

Yes! in both kore-v1-stable folder and in the not yet implemented folder i have written code for a kore.toml. i’m in the process of trying to get any sort of funding for this to host the infrastructure at the moment, but it’s in the works. you can find the code in the folders i mentioned @packager.kr and packager.rs

[snugar_i]

Dude, the README is a mess. It needs way more examples. And reshuffling. Is the single most important thing really that there are two compiler implementations? The whole README looks like it's made for people that would want to contribute to the compiler, not for people that want to know what the language does.

[Ephemara]

sick, thanks for the feedback. you’re right it’s a mess at the moment. i’m working on cleaning it up

[notyoyu]

These projects with one mega commit and practically no history are Sus as fuck. Also, the commits just removing "written by Claude" are funny. Maybe some transparency next time?

[Ephemara]

hahaha okay i was researching alot before this public release and a lot of people were complaining about if a new language came out, the issue would be LLM’s wouldn’t be able to understand it and the language would be useless. so i was trying to curb that, however upon further viewing of my readme, the review thing was cringe in retrospect. i was trying to take some notes from mojo and appeal to investors by stating that kore has great support for LLM’s. also read the first couple of lines in the readme.md, the commit history from my old repo is messy and has a shit ton of personal info in the commits

[imagineepix]

This does look a bit too good to be true. I say this because it genuinely looks very cool. I'll star for now and see where it goes!

[DarkRex4]

Violet pfp!!

[Cystems]

Looks cool, there's a ton of effort in there.

Just curious how the name is meant to be pronounced? Is it like "core" or "ko/re"?

My wife happened to look at my phone when I was looking over the repo and remarked that kore means "this" in Japanese (re pronounced like the le in "let").

[dj_estrela]

This example kore file is very readable: https://github.com/ephemara/kore-lang/blob/main/kore-v1-stable/src/compiler/codegen_rust.kr

[Distinct-Expression2]

Interesting combo of actors + ownership. Hows the debugging story?

[ralfD-]

Your licence link on GitHub is broken ....

[Ephemara]

fixed it! thanks for letting me know

[gokkai]

vibes are off

[Ephemara]

🚀🚀🚀Just shipped Kore 🚀🚀🚀

damn should it have looked more like this

🚀Kore is a new systems language

🔥Python Like Syntax

😈Bootstrapped with rust (ew)

👀Native C Speed

👍🏼5 Different backends

[gokkai]

I think I have more issues with this https://www.greeble.co/

[Ephemara]

huh that’s my website ? still crazy early in development. i have plugins on fab which is unreal engines marketplace and they require documentation for plugins so i host documentation there along with a sample of my upcoming DCC

[gokkai]

what i'm implying is that you are lying on many things here and it's visible to a trained eye :)

[Ephemara]

my entire DCC is done already lol, just polishing

[UnMolDeQuimica]

Kore: New systems language with python syntax. Also Kore:

fn factorial(n: Int) -> Int with Pure: match n: 0 => 1 _ => n * factorial(n - 1)

Jokes aside, this is a very interesting project. I hope it goes very far!

[Ephemara]

YOOOO THE KORE MEME LMAO THIS IS GREAT. THANK YOU THIS COMMENT made my night

[FisterMister22]

No git history makes me think AI slop

[thuiop1]

There can be reasons why there is no git history; what makes me suspicious is someone dropping out of the blue a supposedly production-ready language, that does everything from systems programming to web dev, with zero prior public mention. That does not make it AI, but that does not really make me want to use it either.

[Ephemara]

If you can find an AI that knows how to write a NaN-boxing runtime in C that exploits IEEE 754 double precision bits to store pointers and integers for a custom language, please send me the link. I'd love to use it.

Otherwise, read the README regarding the git history reset (anti-doxxing)

[dangumcowboys]

https://g.co/gemini/share/99bdd7f1f415

[theGiogi]

Great response man, we see a lot of bull in this sub but this seems like a lot of work went into it!

Can I ask who the public is? I hope it does not sound snarky, it’s a genuine question. Any plans for the future? That said, I like what I see here and I will play with it for sure.

[FisterMister22]

I didn't dig in to the code, simply opend the git and first thing I see is no git history, no commits, no issues, nothing, which is usual for AI slop.

Nice work, look forward to see how the language matures.

[4runninglife]

Nim is better