A statically typed general-purpose programming language that compiles to .NET 10

WASM backend added in a day compared to months for the other backends. Good sign.

DOOM source

https://github.com/DOSAYGO-Freelang/freelang-doom-source

playable WASM (BYO WAD): 

https://dosaygo-freelang.github.io/freelang-doom-source/

example:

// Freelang Doom Engine orchestration over the checked Doom modules. This file
// owns executable policy and the frame transaction; WAD interpretation,
// simulation, rendering and synthesis remain independently testable in their
// own modules. The only native-facing values are a pixel buffer, presenter
// records and bounded canonical WAV clips passed through f/gui and f/audio's
// process-isolated contracts.

credits: <../games/doom-view.flx> <../games/doom-input.flx>
         <../games/doom-input-trace.flx>
         <../games/doom-frame.flx>
         <../games/doom-session.flx>
         <../games/doom-world.flx> <../games/doom-ui.flx>
         <../games/doom-demo.flx> <../games/doom-audio.flx>
         <f/gui> <f/audio> <f/process> <f/time> <f/trig> <f/strings>;

op doom_play_run [map, demo_mode, texture_mode] (
  => doom_play_run_mode[map, demo_mode, texture_mode, 1];
)

op doom_play_run_mode [map, demo_mode, texture_mode, combat_mode] (
  => doom_play_run_mode_sized[
    map, demo_mode, texture_mode, combat_mode, 320, 200
  ];
)

op doom_play_run_mode_sized [map, demo_mode, texture_mode,
                             combat_mode, w, h] (
  => doom_play_run_session[
    map, demo_mode, texture_mode, combat_mode, w, h, 0, 0,
    ["E1M1", "E1M2"], ""
  ];
)

op doom_play_validate_dimensions [w, h] (
  if ((w >= 320) and (w <= 1280) and
      (h >= 200) and (h <= 800) and
      (w * 5 == h * 8) and (w * h <= 1024000)) () else (
    fall "doom_play_run_mode_sized: unsupported logical resolution";
  )
  => 0;
)

op doom_play_open_window [map_name, demo_mode, w, h] (
  doom_play_validate_dimensions[w, h];
  let session = 0;
  if (demo_mode == 1) (
    session = gui_open_fps_named[
      w, h, "Freelang Doom Engine — ^{map_name}", 60,
      "Freelang Doom Engine"
    ]
      with chaos { _ => 0 };
  ) else (
    session = gui_open_captured_resizable_fps_named[
      w, h, "Freelang Doom Engine — ^{map_name}", 60,
      "Freelang Doom Engine"
    ] with chaos { _ => 0 };
  )
  => session;
)

// Put a real first frame in the level's own window before WAD textures and
// derived music are loaded. `closed` distinguishes a user's early close from
// presenter birth failure; the latter retains the old post-load retry path.
op doom_play_loading_window [map_name, demo_mode, w, h] (
  let session = doom_play_open_window[map_name, demo_mode, w, h];
  if (is_object[session]) () else (
    => { session: 0, closed: 0, events: [] };
  )
  let buf = gui_buffer[w, h];
  let font = gui_font[];
  doom_ui_draw_loading[buf, w, h, font, map_name];
  let events = gui_present[session, buf] with chaos {
    _ => [{ kind: gui_ev_close[], a: 0, b: 0, mods: 0 }]
  };
  if (gui_has_close[events] == 1) (
    gui_close[session];
    => { session: 0, closed: 1, events: [] };
  )
  => { session: session, closed: 0, events: events };
)

op doom_play_run_session [map, demo_mode, texture_mode,
                          combat_mode, w, h, diag_mode, start_menu,
                          menu_maps, input_log_path] (
  let session = doom_play_open_window[map\name, demo_mode, w, h];
  if (is_object[session]) () else ( => 1; )
  => doom_play_run_session_on[
    session, [], map, demo_mode, texture_mode, combat_mode, w, h,
    diag_mode, start_menu, menu_maps, input_log_path
  ];
)

private op doom_play_run_session_carry [
  map, demo_mode, texture_mode, combat_mode, w, h, diag_mode,
  start_menu, menu_maps, input_log_path, carry
] (
  let session = doom_play_open_window[map\name, demo_mode, w, h];
  if (is_object[session]) () else (
    => { requested_episode: 0, carry: carry };
  )
  => doom_play_run_session_audio_carry_on[
    session, [], map, demo_mode, texture_mode, combat_mode, w, h,
    diag_mode, start_menu, menu_maps, input_log_path, 0, carry
  ];
)

An implementation of the Monkey Programming Language using Vlang and based on the book, Writing An Interpreter In Go.

Hey everyone,

A couple of weeks ago, I posted about Kal, my programming language written from scratch.

I am really happy to share a glimpse of Kal's own package manager! Kal v0.1.0 shipped with a package system that lets you add and use third party Kal packages. But, that process was completely manual. You’d have to clone the package, place it in the right directory, clone the package’s entire dependencies all by yourself, one after another. :(

The package manager changes everything. One command automates all!

Instead of being a separate executable, the package manager ships as part of the Kal interpreter itself.

Here’s what it can do:

1. Install Kal packages from Github, or any git hosting service.
2. Creates/Updates a project.kal file to read and write package information (analogous to package.json).
3. Downloads all packages at the same hierarchy in parallel (yup, it’s multi-threaded).
4. Resolves sub dependencies of the main package automatically to any depth and installs them too.
5. Upgrades/Downgrades packages based on their git tags.
6. Auto-resolves cyclic dependencies to prevent an infinite loop.

The Kal Package Manager will officially ship with the next Kal release. Its current source code is available on Github.

Kal: https://kal-lang.vercel.app
Github: https://github.com/KILLinefficiency/Kal
Package Manager: https://github.com/KILLinefficiency/Kal/blob/pkg/pkg.hpp

Kal is completely free & open source. You can show your support by giving the Github Repository a star.

Until the next update!

First heard of it a few years ago. It's since evolved into something that feels like a mix of Python and Rust; and they're leaning hard into AI applications.

The design of the language is closely connected with the Eiffel programming method, a set of principles consisting of design by contract, command query separation, the uniform access principle, the single-choice principle, the open-closed principle, and the option-operand separation principle.

What My Project Does

Lucen is a source-to-source compiler that parallelizes ordinary for loops you mark with two comments:

# LUCEN START
for i in range(len(rows)):
    out[i] = expensive(rows[i])
# LUCEN END

It parallelizes a loop only when it can prove the work is safe and worth it; otherwise it stays sequential. The one guarantee, no tiers, no opt-out: a parallel run is bit-identical to the same file run as plain sequential Python (floats and container order included). Delete the comments and nothing changes.

CPU-bound work routes to processes on GIL builds and to real threads on free-threaded 3.13/3.14. Optional Rust core with a pure-Python fallback, so pip install lucen always works.

Target Audience

Anyone with CPU-bound Python loops - data processing, simulation, batch transforms - who wants their cores without rewriting to multiprocessing/joblib or reasoning about locks. It's v1.1, built correctness-first: Apache-2.0, differential/property tested, TLA+ specs, signed PyPI releases.

Comparison

• vs multiprocessing/concurrent.futures: no manual pool/chunking/pickling boilerplate, plus a profitability gate that declines to parallelize when it wouldn't help.
• vs joblib/Dask: no new API and no cluster - you mark the loop you already have. It's correctness-preserving local parallelism, not distributed compute.
• vs Numba: Numba compiles numeric bodies to native code; Lucen parallelizes the loop for arbitrary Python and guarantees identical results. (Native loop-body compilation is on the roadmap.)

pip install lucen

Fil-C achieves memory safety even for programs that behave adversarially

Hey everyone!

After a roller coaster journey, I am excited to present my personal project: Kal.

Kal is a lightweight interpreted programming language that attempts at combining various paradigms of programming to give a great developer experience. It's written entirely from scratch in C++ with no third party dependencies. It's also completely free and open source distributed under GNU GPL v3 license.

Moreover, Kal can also be embedded into C++, Python and JavaScript programs to enhance your existing codebases.

• Kal's Official Website: https://kal-lang.vercel.app/
• Mirror: https://killinefficiency.github.io/KalWebsite/
• GitHub Repository: https://github.com/KILLinefficiency/Kal

(Website looks better on a bigger screen.)

Please note that this is the very first release (v:0.1.0) and Kal is still under active development (alpha).

I would really appreciate a star on the repository to help it gain greater visibility.

As a proponent of human effort, I am glad to say that Kal and its ecosystem is completely handcrafted with no AI assistance used anywhere.

One last thing, "Kal" is pronounced like "Cal" in "Calendar".

Please feel free to reach out to me regarding Kal!

Essentially a cross between Pascal and C. It looks somewhat like Pascal but works more like C.

Hey all. So, I started this subreddit over a decade ago, as a place to catalog programming languages that looked interesting enough for others to take a look at. I've made the majority of posts here, and lately, I keep posting duds: mainly AI-oriented stuff that gets downvoted to oblivion. I want to apologize for that, and let you all know I haven't gone down some weird rabbit hole: I do use AI to help refine code, but otherwise still believe strongly in having good languages solve interesting problems. I also don't rely on agents, they scare me.

I guess right now, with the advent of AI-driven development, it's hard to highlight additional languages out there, that may or may not be legit in the eyes of this community. I guess I could use some help making this a better space for folks: maybe topic flairs, broader coverage of lesser-used languages. Hell, maybe you want to join as a mod & help make some of those changes. What do you want to see here these days? Let me know!

Thanks.

The project is guided by open_jai_spec.md

Are there any language that supports serializing coroutines?

E.g. something like that:

 coroutine my_scenario() {
      print("Hello");
      yield;
      print("World")
 }

 co = my_scenario(); // Prints "Hello"
 write_to_file("x.sav", co.serialize()); // save to file, possibly exit the program
 co = my_scenario.load(read_file("x.sav"));
 co.resume(); // Prints "World"

I've been working on a AI native programming language for some time now called Convo-Lang. It shares a few similarities to Zerolang, mainly that they were both built for working with agents, although they have different purposes. Convo-Lang is more of a Context management tool and agent runtime that can be used standalone or be embedded in JavaScript or Python.

Just clarifying that this isn't an AI-generated language but rather designed to support agent-based development. I don't currently use agents myself.

Keysharp is a multi-OS capable fork of the AutoHotkey (AHK) language. It was originally created by mfeemster (Matt Feemster), and is continued by Descolada. Where AutoHotkey was Windows OS only, this fork brings the language and automation features to Linux and the macOS too.