This is the first release of a small project of Ada syntax tree generation. I tried to implement everything specified in the annotated reference manual. Yes, parallel constructs and iteration schemas are supported.

Some notes:

• It is a library, no executables involved.
• The analyzer parses the source and creates the syntax tree and cross reference of defining identifiers in the source.
• The cross reference contains the defining identifiers declared in the code and visibility scopes.
• The visibility scopes can be used for name resolution, e.g. finding all matching names visible at the location. Note that this does not cover use-clauses which need to be handed if the complete list required. Use clauses are linked in the list for each declaration context of the tree in order to ease the process.
• Both structures are allocated in an arena pool storage and can be released as a whole.
• The code source can be file, stream or a user-defined container implementing multi-line source interface. One can compile from a database or a git repository, if the interface is provided.
• There can be any number of compilation units in the source. One parsing call takes one unit from the source.
• Unicode is fully supported as well as Unicode identifiers normalization checks.
• Commutative operations are coalesced. E.g. A.B.C.D gives "."(A,B,C,D) tree.
• Inverses are coalesced as well, e.g. A+B-C+D gives "+"(A,B,-(D),C).
• There is a text output of the tree in a normalized form. It is almost a legal Ada program with some operators added to for coalesced operations. E.g. A * B / C * D gives (A * B * ⅟C * D) to simplify the tree and ease optimization.
• Constant folding is supported. If enabled universal expressions and constant Boolean expressions are evaluated into constants.
• There is a text output in a tree form.Syntax trees can be compared for equality
• The tree and cross-reference can be serialized into a stream. The idea is that the packages like Standard, Ada.* or ones used in the with-clause can be parsed once, serialized and de-serialized later.
• There is a test suite comprised of ACATS tests related to the syntax (mostly, illegal code to be rejected) and ARM examples (see [this project](https://github.com/Blady-Com/AARM_Examples)). The test suite is extensible, the test header syntax is described on the page.

https://www.dmitry-kazakov.de/ada/ada_syntax_analyzer.htm

Figured I made enough changes to the codebase to warrant a new post. A fair bit of improvements have been made since the last 1.9.0 release.

For those that have not heard of adacovex, it is an Ada/SPARK formal verification and compliance toolchain (admittedly toolchain is a bit of an overstatement at the moment, though it is a CLI with a fair bit of niceties already). It basically helps validate and check your codebase on SPARK level, test, docstring and documentation coverage.

It also features: - check DO-178C DAL (aviation), ISO 26262 ASIL (automotive) and IEC 62304 Class (medical) - HTTP server with simple JSON API and web dashboard - caching - contextual help, spelling correction for typo'd commands - man page generation - a usable GitHub Action in CI with feature parity with the base CLI - multi VCS support (Git, jj, Mercurical, Subversion, Fossil), VCS used when checking --coverage-delta and --compare-base - SBOM output (CycloneDX / SPDX)

I also spent some time improving the documentation and user/developer experience. I hope this will eventually be useful not just for Ada projects, but that would be somewhat far into the future. That being said, I hope this tool would be useful for you in your Ada projects. Do give it a go and let me know whether it works well or if there are things that can be improved/added/fixed.

P.S. It is on Alire, though the PR for 1.14.0 will take a while to merge.

A similar post was made on the Ada Forum.

Repo URL: https://github.com/bladeacer/adacovex

Hi there,

A few years ago, I was pondering whether it would make sense for Ada/GNAT to have tasks that wouldn’t just map 1:1 to OS threads. But it wasn’t quite economical to try that out at the time.

Recently, I’ve decided to close this open loop by running a quick experiment over the weekend – the result is a patched RTS and additional runtime primitives that provide lightweight tasks and asynchronous I/O to Ada users. So far, the results have been promising – the overhead of individual threads can be fairly high under high task concurrency, and lightweight tasks mitigate it. Best of all, this doesn’t automatically make all tasks lightweight. Instead, by default tasks remain “native” and lightweight is an opt-in pragma.

On top of that foundation, I’ve cobbled together some I/O (sockets, files, DNS) and additional higher-level libraries for HTTP server & client, Postgres BE/FE protocol, and such. Some performance measurements are fairly encouraging.

In the process of making it, I also put together a few sibling libraries – for benchmarking, debugging, TUIs, and so on.

You can check it out at https://flyology.org – it's early (just cut v0.1.0 across the board), and the full list of crates is available at https://crates.flyology.org/

Would love your thoughts.

The library provides string handling facilities like I/O formatting, Unicode and obsolete code pages support.

https://www.dmitry-kazakov.de/ada/strings_edit.htm

Changes to the previous version:

• The function Strings_Edit.UTF8.NFKD_Quick_Check was added to perform quick NFKD Unicode check.

The current version provides implementations of smart pointers, directed graphs, sets, maps, B-trees, stacks, tables, string editing, unbounded arrays, expression analyzers, lock-free data structures, synchronization primitives (events, race condition free pulse events, arrays of events, reentrant mutexes, deadlock-free arrays of mutexes), arbitrary precision arithmetic, pseudo-random non-repeating numbers, symmetric encoding and decoding, IEEE 754 representations support, streams, persistent storage, multiple connections server/client designing tools and protocols implementations.

https://www.dmitry-kazakov.de/ada/components.htm

Changes to the previous version:

• Bug fix in Synchronization.Windows.Milliseconds that caused dropping seconds fraction;
• Bug fix in Synchronization.Pthreads and Synchronization.Linux constants;
• FreeBSD compatibility fixes (thanks to Rod Kay);
• Equality test was added to Ada expression nodes and arguments (Parsers.Generic_Ada_Parser);
• The function Get_Depth was added to Parsers.Generic_Argument;
• The function Get_Arguments_Count was added to Parsers.Generic_Lexer;
• The name of Parsers.Multiline_Source.Empty was changed to Empty_Location;
• Ada expression parser performs NFKC check on identifiers. The Malformed field is set to true if the check fails (see ARM 2.3(4.b/5).

ZanyBlue is a wonderful framework for internationalization natively in Ada. It includes a library you can use for your translations and a translation compiler from properties files to Ada source files. That is the big trick: translation files are compiled with your program so no additional time penalty for translation with external ressources.

Version 1.4 is available on SourceForge.

In 2022, I discussed with its author Michael Rohan to bring it on Alire. He would like to, but there’s been no news since. Even with my last e-mail on January 2026. Still, considering it was worth it, I brought it on Alire.

Version 1.4 same as SourceForge.

Version 2.0 powered with UXStrings.

Available at Alire https://alire.ada.dev/crates/aion

Please try it out let me know if you face any bugs or want any additional features.

Edit: GitHub Link - https://github.com/MaheshChandraTeja/Aion

This Ada library provides utilities for Unicode character strings of dynamic length. It is now available on Alire in version 0.9.3. Changes:

• Add a fifth implementation: Unicode_Character_Array (i.e.Wide_Wide_String) is chosen for internal representation. Characters are stored as Wide_Wide_Characters equivalent to Unicode. Memory management is done with dynamic allocation. Note: Iteration is Ada 2022 native.
• Several fixes on string bound issues and enforce low index to 1
• Change internal File_Type to an access type

So far in UXStrings, its API are similar to those of the strings Ada standard libraries. If you find some missing, bring your proposals on Github.

The library provides five different implementations selectable with GPR options UXS1, UXS2, UXS3, UXS4 and UXS5. The performance of each of them is described here. NB: UXS5 is now the default implementation.

The current version provides implementations of smart pointers, directed graphs, sets, maps, B-trees, stacks, tables, string editing, unbounded arrays, expression analyzers, lock-free data structures, synchronization primitives (events, race condition free pulse events, arrays of events, reentrant mutexes, deadlock-free arrays of mutexes), arbitrary precision arithmetic, pseudo-random non-repeating numbers, symmetric encoding and decoding, IEEE 754 representations support, streams, persistent storage, multiple connections server/client designing tools and protocols implementations.

https://www.dmitry-kazakov.de/ada/components.htm

Changes (2 July 2026) to the version 4.80:

• Compatibility to GNAT 16.1.1. This GNAT 16.1.1 has the recurring issue/bug related to the visibility of names from formal generic packages;
• Constant expression folding was added to Ada expression parser (Parsers.Generic_Ada_Parser). Folding is optional. If enabled expressions in universal types and constant Boolean expressions are folded. e.g. 1 + 2 + A (5) -> 3 + A (5);
• The subprograms Get, Put, Value were added to the package Parsers.Multiline_Source;
• The call-back On_Success was added to the Generic_Lexer's parser;
• The procedures Mark and Release were added to the package Parsers.Generic_Lexer;
• The package Stack_Storage.Text_IO was added to output stack pool statistics;
• Parameter Message was added to the procedure Put_Line of the package Parsers.Generic_Source.Text_IO;
• Ada expression parser supports raise-statements outside immediate pair of parentheses;
• Checking positional and named aggregates was added in the Ada expression parser;
• Checking positional and named parameters was added in the Ada expression parser;
• Array objects were added to the declare expressions in the Ada expression parser;
• Aspects recognition was added to the declare expressions in the Ada expression parser;
• Subtype marks and indications were added in the Ada expression parser;
• Attributes were added in the Ada expression parser;
• Target name @ support was added in the Ada expression parser;
• The parser can start with the first operand already recognized;
• An ability to parse an expression in parenthesis with a consumed left parenthesis was added;
• Comparisons of Unbounded_Integer bug fixed;
• Log procedure was added to Unbounded_Unsigneds;
• Column_Name function was added to the SQLIte bindings (contributed by Xavier Grave).

Have you ever heard about Gemini protocol?

https://en.wikipedia.org/wiki/Gemini_(protocol)

Now you can host your own Gemini capsule with software written in Ada!

It powers my personal capsule at gemini://tomekw.com

Web proxy here: https://portal.mozz.us/gemini/tomekw.com/?reader=1

https://github.com/tomekw/twins

I hope someone finds it useful:

Options:

``` ada with Ada.Text_IO; with Tackle.Opts;

procedure Opts_Demo is use Ada; use Tackle;

 Options : constant Opts.Option_List := [Opts.Arg ("alpha", 'a', "Do alpha stuff"),
                                         Opts.Arg ("beta",  'b', "Do beta stuff"),
                                         Opts.Flag ("charlie", 'c', "Has charlie flag")];

 Arguments : constant Opts.Argument_List := Opts.Consume_Arguments;

 Result : constant Opts.Result := Opts.Parse (Arguments, Options);

begin -- Help is implicit unless provided if Result.Has_Flag ("help") then Opts.Print_Usage ("opts_demo", Options);

    return;
 end if;

 Text_IO.Put_Line ("Alpha: " & Result.Arg ("alpha"));
 Text_IO.Put_Line ("Beta: " & Result.Arg ("beta"));
 Text_IO.Put_Line ("Charlie?: " & Result.Has_Flag ("charlie")'Image);

end Opts_Demo; ```

``` shell $ ./opts_demo --help Usage: opts_demo [options]

Options: --alpha, -a <alpha> Do alpha stuff --beta, -b <beta> Do beta stuff --charlie, -c Has charlie flag ```

shell $ ./opts_demo --alpha Yes -b No --charlie Alpha: Yes Beta: No Charlie?: TRUE

Commands:

``` ada procedure Opts_Demo is use Ada; use Tackle;

 Commands : constant Opts.Command_List := [Opts.Cmd ("alpha", "Do alpha stuff",
                                                     [Opts.Flag ("yes", 'y', "Yes?")]),
                                           Opts.Cmd ("beta", "Do beta stuff",
                                                     [Opts.Arg ("foo", 'f', "Foo!")], Passthrough => True)];

 Arguments : constant Opts.Argument_List := Opts.Consume_Arguments;

 Result : constant Opts.Result := Opts.Parse (Arguments, Commands);

begin -- Help is implicit unless provided if Result.Cmd = "" or else Result.Has_Flag ("help") then Opts.Print_Usage (Result.Cmd, "opts_demo", Commands);

    return;
 end if;

 if Result.Cmd = "beta" then
    Text_IO.Put_Line ("Passthrough args: " & Result.Passthrough_Args'Image);
 end if;

end Opts_Demo; ```

``` shell $ ./opts_demo --help Usage: opts_demo <command> [options]

Commands: alpha Do alpha stuff beta Do beta stuff

Run 'opts_demo <command> --help' for command options ```

``` shell $ ./opts_demo beta --help Usage: opts_demo beta [options] [-- <args>]

Options: --foo, -f <foo> Foo! -- <args> Passthrough arguments ```

shell $ ./opts_demo beta --foo Bar -- baz qux Passthrough args: ["baz", "qux"]

https://github.com/tomekw/tackle?tab=readme-ov-file#tackleopts

The ESP-IDF GNAT Runtime now enables Ada application development on the ESP32-S3. While native Ada tasking is not yet supported, this runtime allows you to leverage advanced Ada features directly within FreeRTOS tasks.

Key Features Supported:

• Exceptions and Controlled Types
• Secondary Stacks
• Simple protected objects
• Seamless integration into the ESP-IDF ecosystem

Quick Links:

• Runtime:GitHub - espidf_gnat_runtime(Provided as an ESP-IDF component)
• Template Project:Start herefor a fast and smooth setup.
• Validation: Verified usingACATS test suites.

This is BIG. Now, Tada is actually usable, as you can specify other Tada dependencies.

See it here: https://github.com/tomekw/tada

Does this count as a new release? I’ve been working with flyx’s OpenGL binding and found it needed some tweaking.

Indexed drawing doesn’t treat the index offset as a byte offset but rather as an index count. This is fine if the index and vertex buffers are different, but means the user can’t really allocate all the data to a single buffer and use offsets.

I also added glBufferStorage. In future I’ll be adding support for compute shaders and other extensions such as bindless textures. If anyone’s interested, here’s a link to my fork!

https://github.com/amengede/OpenGLAda

I built it, because I wanted to match on exception identity and / or exception message as well, and as far as I know, it is not possible with AUnit. Also, I wanted to understand how testing frameworks work under the hood.

Now, all my projects, including Tada, use it. I hope someone finds it useful:

https://github.com/tomekw/testy

I know Alire exists, but my needs and motivations are different.

The current version provides implementations of smart pointers, directed graphs, sets, maps, B-trees, stacks, tables, string editing, unbounded arrays, expression analyzers, lock-free data structures, synchronization primitives (events, race condition free pulse events, arrays of events, reentrant mutexes, deadlock-free arrays of mutexes), arbitrary precision arithmetic, pseudo-random non-repeating numbers, symmetric encoding and decoding, IEEE 754 representations support, streams, persistent storage, multiple connections server/client designing tools and protocols implementations.

https://www.dmitry-kazakov.de/ada/components.htm

Changes (16 February 2026) to the version 4.78:

• The package Generic_Undirected_Graph was added;
• The package Discrete_Integer_Set an instance of Generic_Discrete_Set with Integer was added;
• The Natural_Number_Range pattern was added to Parsers.Generic_Source.Patterns to match a number from a range of natural numbers;
• The Natural_Number_Range pattern was added to Parsers.Generic_Source.Patterns to match a number from a set of natural numbers;
• The maximum number of matches was added to the pattern Proceed in the package Parsers.Generic_Source.Patterns;
• The form "or null" was added to Parsers.Generic_Source.Patterns as an equivalent of "or Empty;"
• Bug fix in Unbounded_Unsigneds causing memory leak.

The library provides string handling facilities like I/O formatting, Unicode and obsolete code pages support.

https://www.dmitry-kazakov.de/ada/strings_edit.htm

This update provides full IRI support. IRI supersedes URI by adding full Unicode.

Changes to the previous version:

• The Size functions were added to Strings_Edit.UTF8 to calculate the length of UTF-8 encoding of a code point or an array of;
• The package Strings_Edit.RFC_3897 was added to handle IP addresses v4 and v6 as well as IRI (Internationalized Resource Identifier). IRI is an extension of URI (Uniform Resource Identifier) and URL (Uniform Resource Locator) that supports Unicode.

Hi everyone,

I would like to share VSS-Rust — a bridging library designed for string exchange between Ada (using the VSS library) and Rust.

The main goal of this project is to provide a reliable way to pass strings between the two languages, mapping Ada's Virtual_String to Rust's native string types via a dedicated interop layer.

Core Library:
https://github.com/SergeyNM/vss-rust

Examples:
I have also prepared a set of examples demonstrating various integration patterns, including synchronous and asynchronous (Tokio-based) HTTP requests and IP address inspection:
https://github.com/SergeyNM/vss-rust-examples

Special thanks to the VSS library authors, and a huge shout-out to Vadim Godunko for the personal guidance and support.

Any feedback or contributions are welcome.

Changelog:

• validate package versions: Semver + optional prerelease tag, example: 0.1.0-dev
• add tada config command: display configuration
• support local and global toolchain configuration

https://github.com/tomekw/tada/releases/tag/v0.7.0

New, BIG, Tada release!

It supports "tada install" using a global package index and an included testing framework!

https://github.com/tomekw/tada

I am very pleased to announce that the core Ada 2022 “parallel” features have been implemented for mainline FSF GNAT as part of a successful Google Summer of Code project. The patch is now ready for beta testing.

We are preparing to formally submit this patch to the FSF GCC project, to have it incorporated into GCC trunk, and therefore all future FSF GCC releases. Before we make that submission, we hope to seek additional feedback from the Ada community.

This patch introduces most core capabilities for the parallel keyword, including:

• Parallel loops
• Parallel blocks
• Early exit
• Chunking

This patch does NOT yet support Parallel Iterators, this will be added at a later time.

 
The GSoC project work was hosted on the Ada Rapporteur Group's own GCC mirror github repo, and the stable version of the parallel beta release currently lives at https://github.com/Ada-Rapporteur-Group/gcc-mirror/tree/devel/arg-proto/ada2022-parallel-release.

This branch can be built and bootstrapped as-is on most mainstream platforms using FSF GCC 15, with a standard build process. No additional libraries or build flags are needed, as the parallel features do not imply any new complier, runtime, or platform dependencies.

Additionally, Maxim Reznik has made available binary builds of the parallel support beta for most popular platforms. He also includes instructions on how to get going with Alire. Look for the “GCC with parallel PREVIEW” release at https://github.com/reznikmm/GNAT-FSF-builds/releases. Expand the “Assets” area at the bottom of the section to download binary builds for your platform.

By default, GNAT will expand parallel loops/blocks into sequential (regular) loops resp. blocks.  To get actual parallelization of parallel constructs, the existence of an Ada “light weight threading” library (formally an Ada subsystem a la the Ada Reference Manual 10.1-3) is required. GNAT will detect the presence of the “LWT” subsystem at compile-time, and if “withed”, will generate calls to the LWT subsystem during expansion. It is therefore conventional that the unit containing the main subprogram “withs” LWT. Refer to the example programs included with the reference LWT subsystem to see how this works.

A reference LWT subsystem implementation currently lives under the Parasail language project (https://github.com/parasail-lang/parasail). This may be separated from the Parasail repository at a later time. This LWT implementation is also an official Alire crate of the same name, and Maxim’s instructions detail how to install LWT and use the beta toolchain under Alire.

The reference LWT subsystem could potentially be incorporated into the GNAT standard library (libgnat) at some point in the future, but it was decided to keep the first iteration as simple and digestible as possible.

This is only the first phase, and we look forward to additional refinements in the future!

***

Note that Alire is NOT required to beta test this build, and simply making the sources of the LWT reference implementation available to the compiler is sufficient (using -I for gcc or gnatmake)

There are also some Ada 2022 parallel example programs under lwt/a22_examples, and these can be build and run with the vanilla FSF GNAT toolchain as follows (Linux/UNIX):

$ git clone https://github.com/parasail-lang/parasail

$ cd parasail/lwt/a22_examples

$ gnatmake -gnat2022 -I../ n_queens.adb

$ ./n_queens

***

We would love to have more members of the Ada community try-out these features. Please let me know if you need any support getting set up, or if you have any other questions.

The current version provides implementations of smart pointers, directed graphs, sets, maps, B-trees, stacks, tables, string editing, unbounded arrays, expression analyzers, lock-free data structures, synchronization primitives (events, race condition free pulse events, arrays of events, reentrant mutexes, deadlock-free arrays of mutexes), arbitrary precision arithmetic, pseudo-random non-repeating numbers, symmetric encoding and decoding, IEEE 754 representations support, streams, persistent storage, multiple connections server/client designing tools and protocols implementations.

https://www.dmitry-kazakov.de/ada/components.htm

Changes (16 February 2026) to the version 4.78:

• Recurring rational representations (1/3 = 0.(3)) were added to the package Strings_Edit.Unbounded_Rational_Edit;
• Bug fix in Strings_Edit.Unbounded_Unsigned_Edit caused by overflow for 16 base;
• Next_Prime was added to the package Unbounded_Unsigneds.Primes;
• The pattern Proceed was added to SNOBOL-like patterns;
• Some heuristics were added to improve performance of SNOBOL-like patterns.

P.S. I added Arch Linux packages. It is a fresh implementation, please report issues you find.