<p>Axelang is a new systems programming language designed around the following question:</p>

<blockquote>
<p><em>Why is concurrency an afterthought, a library, or a bolt-on runtime — as opposed to a language-level concept?</em></p>
</blockquote>

<p>Axe aims to resolve the issue in that rather than forcing developers to manually struggle with bolted on threads, locks, futures and external libraries, Axe makes concurrency part of the core language semantics, in that writing Axe forces you to think concurrently by default.</p>




<h2>
  
  
  Why Axe Exists
</h2>

<p>Modern CPUs have not been about single-thread speed for a long time. Performance improvements are generally achieved by:</p>

<ul>
<li>Adding more cores</li>
<li>Adding more threads</li>
<li>Hiding I/O latency</li>
<li>Overlapping compute with work</li>
</ul>

<p>But most languages still make concurrency:</p>

<ul>
<li>verbose</li>
<li>error-prone</li>
<li>tacked on after the fact</li>
</ul>

<p>C, C++, Java, and Rust rely heavily on APIs, libraries, and patterns. Go introduced goroutines, but concurrency is still a runtime abstraction — not part of the language type system. Concurrency should feel like a natural mode of thinking, not a box of add-on primitives.</p>




<h2>
  
  
  Concurrency as a Language Construct
</h2>

<p>A simple Axe program might include:<br>
</p>

<div class="highlight js-code-highlight">
<pre class="highlight plaintext"><code>main {
    parallel {
        single {
            task1();
            task2();
        }
        task3();
    }
}
</code></pre>

</div>



<p>This reads almost like pseudocode:</p>

<ul>
<li>
<code>parallel {}</code> introduces a parallel execution region</li>
<li>
<code>single {}</code> means “one thread runs this block”</li>
<li>work-sharing and scheduling are handled by the compiler + runtime</li>
</ul>

<p>Axe’s concurrency constructs are structured, visible in the syntax tree, easy for static analysis, and safe to optimize.</p>

<p>Instead of bolting on OpenMP-style pragmas, heavy macro systems, or attributes, Axe builds them directly into the grammar.</p>




<h2>
  
  
  Platform-Aware Code at Compile Time
</h2>

<p>Axe also supports compile-time dispatch based on OS or platform:<br>
</p>

<div class="highlight js-code-highlight">
<pre class="highlight plaintext"><code>platform windows {
    println "Running on Windows";
}
platform posix {
    println "Running on POSIX";
}
</code></pre>

</div>



<p>This allows the compiler to eliminate unused branches, generate smaller binaries, and avoid runtime platform checks.</p>

<p>Your code can remain portable without littering your project with <code>#ifdef</code> walls.</p>




<h2>
  
  
  A Powerful Dispatch System… Without Generics
</h2>

<p>One standout feature is Axe’s compile-time overload map:<br>
</p>

<div class="highlight js-code-highlight">
<pre class="highlight plaintext"><code>overload println(x: generic) {
    string =&gt; println_str;
    i32    =&gt; println_i32;
}(x)
</code></pre>

</div>



<p>This looks simple, but it’s extremely powerful:</p>

<ul>
<li>Axe can resolve overloads statically</li>
<li>No generics required</li>
<li>No template instantiation explosion</li>
<li>No runtime dispatch cost</li>
<li>Works with user-defined types</li>
</ul>

<p>This lets Axe provide generic-friendly ergonomics without introducing template systems or complex type parameterization.</p>




<h2>
  
  
  Familiar, But Cleaner
</h2>

<p>Axe feels like a blend of:</p>

<ul>
<li>C-style syntax</li>
<li>Go-like readability</li>
<li>Rust-level respect for correctness</li>
<li>Zig-style minimalism</li>
</ul>

<p>But it doesn't copy any of them. Axe aims to be:</p>

<ul>
<li>easier than C++</li>
<li>more predictable than Rust’s borrow checker</li>
<li>more explicit than Go</li>
<li>safer than straight C</li>
</ul>

<p>If you know a systems language, you can read Axe code in minutes.</p>




<h2>
  
  
  A Language Designed to Scale
</h2>

<p>Axe has:</p>

<ul>
<li>models (its version of simple data types)</li>
<li>functions with clear signatures</li>
<li>compile-time branching (for platforms, modes, and toolchains)</li>
<li>parallel loops and reduction built in</li>
</ul>

<p>Example parallel loop:<br>
</p>

<div class="highlight js-code-highlight">
<pre class="highlight plaintext"><code>parallel for mut i = 0 to n reduce(+:sum) {
    sum = sum + i;
}
</code></pre>

</div>



<p>The compiler turns this into efficient work sharing, correct reduction handling, and thread safe execution.</p>

<p>It does not require a single pragma, library import, or thread API.</p>




<p>You can read more or try it at:</p>

<p><a href="https://axelang.org" rel="noopener noreferrer">axelang.org</a></p>

Axelang هو لغة برمجة أنظمة جديدة تدمج التزامن كميزة أساسية. تعالج التحديات الشائعة التي يواجهها المطورون مع اللغات التقليدية، التي غالبًا ما تعتبر التزامن فكرة لاحقة. من خلال دمج التزامن في دلالته الأساسية، تشجع Axelang المطورين على اعتماد ممارسات البرمجة المتزامنة من البداية، مما يتماشى مع بنى المعالجات الحديثة التي تعطي الأولوية للمعالجة المتوازية والخيوط المتعددة.

Axelang es un nuevo lenguaje de programación de sistemas que integra la concurrencia como una característica fundamental. Aborda los desafíos comunes que enfrentan los desarrolladores con los lenguajes tradicionales, que a menudo tratan la concurrencia como un pensamiento posterior. Al incorporar la concurrencia en su semántica central, Axelang anima a los desarrolladores a adoptar prácticas de programación concurrente desde el principio, alineándose con las arquitecturas de CPU modernas que priorizan el procesamiento en paralelo y el multi-threading.

Axelang est un nouveau langage de programmation système qui intègre la concurrence comme une caractéristique fondamentale. Il répond aux défis courants auxquels les développeurs sont confrontés avec les langages traditionnels, qui traitent souvent la concurrence comme une réflexion après coup. En intégrant la concurrence dans sa sémantique de base, Axelang encourage les développeurs à adopter des pratiques de programmation concurrente dès le départ, en accord avec les architectures CPU modernes qui privilégient le multi-threading et le traitement parallèle.

Axelang is a newly developed systems programming language that integrates concurrency as a fundamental feature. It addresses the common challenges developers face with traditional languages, which often treat concurrency as an afterthought. By embedding concurrency into its core semantics, Axelang encourages developers to adopt concurrent programming practices from the outset, aligning with modern CPU architectures that prioritize multi-threading and parallel processing.

Axelang - A Systems Programming Language with Concurrency as a First-Class feature

arXiv:2511.16080v1 Announce Type: cross 
Abstract: Modern data processing workflows frequently encounter ragged data: collections with variable-length elements that arise naturally in domains like natural language processing, scientific measurements, and autonomous AI agents. Existing workflow engines lack native support for tracking the shapes and dependencies inherent to ragged data, forcing users to manage complex indexing and dependency bookkeeping manually. We present Operon, a Rust-based workflow engine that addresses these challenges through a novel formalism of named dimensions with explicit dependency relations. Operon provides a domain-specific language where users declare pipelines with dimension annotations that are statically verified for correctness, while the runtime system dynamically schedules tasks as data shapes are incrementally discovered during execution. We formalize the mathematical foundation for reasoning about partial shapes and prove that Operon's incremental construction algorithm guarantees deterministic and confluent execution in parallel settings. The system's explicit modeling of partially-known states enables robust persistence and recovery mechanisms, while its per-task multi-queue architecture achieves efficient parallelism across heterogeneous task types. Empirical evaluation demonstrates that Operon outperforms an existing workflow engine with 14.94x baseline overhead reduction while maintaining near-linear end-to-end output rates as workloads scale, making it particularly suitable for large-scale data generation pipelines in machine learning applications.

أوبيرون هو محرك سير عمل قائم على لغة راست مصمم للتعامل مع البيانات غير المنتظمة، والتي تتكون من مجموعات تحتوي على عناصر ذات أطوال متغيرة، وغالبًا ما توجد في مجالات مثل معالجة اللغة الطبيعية والقياسات العلمية. يقدم المحرك صيغة جديدة للأبعاد المسماة مع علاقات اعتماد واضحة، مما يسمح للمستخدمين بالإعلان عن خطوط أنابيب مع تعليقات توضيحية للأبعاد يتم التحقق من صحتها. يقوم أوبيرون بجدولة المهام ديناميكيًا مع اكتشاف أشكال البيانات أثناء التنفيذ.

Operon es un motor de flujo de trabajo basado en Rust diseñado para manejar datos irregulares, que consisten en colecciones con elementos de longitud variable comúnmente encontrados en campos como el procesamiento del lenguaje natural y las mediciones científicas. El motor introduce un formalismo de dimensiones nombradas con relaciones de dependencia explícitas, permitiendo a los usuarios declarar tuberías con anotaciones de dimensiones que se verifican por su corrección. Operon programa dinámicamente tareas a medida que se descubren formas de datos durante la ejecución.

Operon est un moteur de flux de travail basé sur Rust, conçu pour gérer les données irrégulières, qui se composent de collections avec des éléments de longueur variable, couramment rencontrées dans des domaines tels que le traitement du langage naturel et les mesures scientifiques. Le moteur introduit un formalisme de dimensions nommées avec des relations de dépendance explicites, permettant aux utilisateurs de déclarer des pipelines avec des annotations de dimensions vérifiées pour leur exactitude. Operon planifie dynamiquement les tâches à mesure que les formes de données sont découvertes pe…

Operon is a Rust-based workflow engine designed to handle ragged data, which consists of collections with variable-length elements commonly found in fields like natural language processing and scientific measurements. The engine introduces a formalism of named dimensions with explicit dependency relations, allowing users to declare pipelines with dimension annotations that are verified for correctness. Operon dynamically schedules tasks as data shapes are discovered during execution, addressing the limitations of existing workflow engines.

Axelang - A Systems Programming Language with Concurrency as a First-Class feature

Was this article worth reading? Share it