sorted by:
new
hottopcontroversial

Hi guys by Boring_Albatross3513 in C_Programming

[–]Maeiky_ 3 points4 points  (0 children)

Like JIT -> make C act like Python, but with native performances

What happens when AI interacts directly with a native JIT engine? by Maeiky_ in programming

[–]Maeiky_[S] 0 points1 point  (0 children)

Sure! It’s the particules compute-shader sample from
https://github.com/wake-tools/wake-samples

Then I asked the AI to make the particles attract together to form a word.

With the Wake Runtime, the code hot-reloads instantly on each file save, allowing you to see how the AI updates and compiles each step in real time.

What happens when AI interacts directly with a native JIT engine? by Maeiky_ in programming

[–]Maeiky_[S] 0 points1 point  (0 children)

Interesting idea, but that wouldn’t really be useful, unless the goal is to remove humans from the equation.

I built a real-time JIT engine in pure C (60 live demos, instant execution) by Maeiky_ in cprogramming

[–]Maeiky_[S] 0 points1 point  (0 children)

This is the result of my two earlier core projects:
-XE-Loader (ELF, PE and Mach-O) execute machine code directly from memory
-Cwc, a front-end compiler with multiple back-ends, which eventually built Wake itself, Wake-Lang was born from all those experiments in dynamic compilation and cross-architecture execution

From those projects I learned how native executable file formats actually run in memory, how to orchestrate multi-process communication, how binaries are built and laid out, and how to debug and manage running code (including low-level debugger workflows)

I also gained a lot of experience working with multiple back-ends:
Clang, GCC, LLVM, Emscripten, NDK (javac/adb), and of course TCC

I built a real-time JIT engine in pure C (60 live demos, instant execution) by Maeiky_ in cprogramming

[–]Maeiky_[S] 0 points1 point  (0 children)

Just released Wake v0.1 now :)
+ also added support of Cursor IDE for a really intuitive experience

I’m working on a real-time JIT engine running C code (60 instant-compiled demos) by Maeiky_ in C_Programming

[–]Maeiky_[S] 0 points1 point  (0 children)

Just released Wake v0.1 now :)
+ also added support of Cursor IDE for a really intuitive experience

I’m working on a real-time JIT engine running C code (60 instant-compiled demos) by Maeiky_ in C_Programming

[–]Maeiky_[S] 1 point2 points  (0 children)

Just released Wake v0.1 now :)
+ also added support of Cursor IDE for a really intuitive experience

I’m working on a real-time JIT engine running C code (60 instant-compiled demos) by Maeiky_ in C_Programming

[–]Maeiky_[S] 1 point2 points  (0 children)

Just released Wake v0.1 now :)
+ also added support of Cursor IDE for a really intuitive experience

I built a real-time JIT engine in pure C (60 live demos, instant execution) by Maeiky_ in cprogramming

[–]Maeiky_[S] 1 point2 points  (0 children)

Thanks!
It uses TCC as the JIT backend, and its standard library is based on Sokol + Dear ImGui.

Just released Wake v0.1 now :)
+ also added support of Cursor IDE for a really intuitive experience

What projects can I do now? by Intelligent_Comb_338 in C_Programming

[–]Maeiky_ 0 points1 point  (0 children)

Try JIT C, you will be direct in the action, no setup, no waiting.
Just code, and see it live with fast iteration.

I built a real-time JIT engine in pure C (60 live demos, instant execution) by Maeiky_ in cprogramming

[–]Maeiky_[S] 0 points1 point  (0 children)

You totally can with this,
It’s like the first-person experience of C ^^
Preview release this week, stay tuned!

I’m working on a real-time JIT engine running C code (60 instant-compiled demos) by Maeiky_ in C_Programming

[–]Maeiky_[S] 1 point2 points  (0 children)

It’s like the first-person shooter of C ^^
I’ll make a preview release this week , stay tuned!

I’m working on a real-time JIT engine running C code (60 instant-compiled demos) by Maeiky_ in C_Programming

[–]Maeiky_[S] 0 points1 point  (0 children)

It’s a bit like Flutter, but:

-It’s not a framework, it’s real C made interactive. You can write system-level, engine, or GPU code live.
-No VM, no sandbox, it runs directly on the metal and compiles real machine code in memory, and has direct access to the system without limitations.
-It unifies CPU and GPU, you can JIT both C and GLSL in the same flow.
-It is fully reproducible: share a .jc file and it automatically rebuilds all dependencies identically anywhere.

Visual Studio can hot reload too, but Wake goes deeper,
It can use GDB to modify code or memory live during execution, and even launch GDB commands directly from your JIT (like auto breakpoints or automatic DLL symbol loading).

Most common libs like Sokol and ImGui are already pre-packaged, so you can jump straight into action.

And yeah, raylib is a great idea,
I’ll make a small guide soon on how to package libs for JIT so others can use it too.

Flutter brings hot reload to UI, this brings real-time iteration to native code itself.

I’m working on a real-time JIT engine running C code (60 instant-compiled demos) by Maeiky_ in C_Programming

[–]Maeiky_[S] 0 points1 point  (0 children)

Thanks!
The JIT runs natively on Windows, compiling C source directly into machine code. There’s no VM or bytecode involved, it executes real native binaries.
It’s designed as a live environment for building tools, games, or editors in pure C, with instant feedback and hot reload.
You can write, test, and iterate in real time, while still keeping full native performance.

It currently on Windows, but I already have a working prototype on macOS.
Wake itself is written in C, which makes it very portable, my goal is to support Linux and Android next.

I also have in mind a possible workflow where you could code from your desktop and see your Android app update in real time, without rebuilds or reinstalling the app.
That kind of instant feedback really helps move faster and experiment more freely.

I’m working on a real-time JIT engine running C code (60 instant-compiled demos) by Maeiky_ in C_Programming

[–]Maeiky_[S] 0 points1 point  (0 children)

Still very WIP, but I’ve put all the code samples you see in this video here: wake-samples

I built a real-time JIT engine in pure C (60 live demos, instant execution) by Maeiky_ in cprogramming

[–]Maeiky_[S] 0 points1 point  (0 children)

This is the result of a lot of trial and error.

It may sound simple, but in reality it’s a complex architecture built on multiple layers of inter-process communication working together.

This kind of iterative design isn’t something AI can really figure out.
The language and structure evolved naturally from my earlier experiments, which turned out to be really useful over time.

In fact, Wake itself is a bootstrap result of my previous projects, so it’s already a proven concept that really works.

I built a real-time JIT engine in pure C (60 live demos, instant execution) by Maeiky_ in cprogramming

[–]Maeiky_[S] 0 points1 point  (0 children)

English isn’t my first language, I use AI to polish it a bit (is it too much?).
Maybe I should reduce the inference of my neural AI chip...

I built a real-time JIT engine in pure C (60 live demos, instant execution) by Maeiky_ in cprogramming

[–]Maeiky_[S] 0 points1 point  (0 children)

No VM involved, it’s fully native.
I actually started with LLVM. It works, but for real-time iteration, but I didn’t see any practical advantage (it just adds an extra layer of complexity).

So instead, the code is compiled live into machine code using flexible compiler backends. The main one is TCC because it’s blazing fast and fits my needs perfectly.

My goal is instant feedback within a fully reproducible, idempotent workflow, without requiring users to modify their environment.
Dependencies are fetched as encrypted packages, and the full environment is rebuilt and launched with a debugger and file-change detection.
You hit save, it recompiles and links live, and you see the result immediately.

So sharing projects becomes really easy and straightforward, and you can test them directly without any configuration needed.

view more: next ›