Post has attachment
Here is a complete puzzle game application written in Ada that uses Felix Krause's OpenGLAda thick binding:

It demonstrates the use of shaders, textures, and glsl330. It runs on both Mac OS-X and Linux.

Post has attachment
"Ten reasons to learn Ada if you know C++ or Java" An article in Russian about #ada

Post has attachment
Nice historical look-back over the history of Ada, and its renewed relevance today, for embedded programming

I'm wondering if anyone here has AdaMagic documentation. Like, what does offset_arith_type or ptr_align align mean in the config. And do you possess adabgen.inf and adacgen.inf because these tools are asking for it and I can't find missing files anywhere. Trying to use AdaMagic extracted from MapuSoft AppCOE with EmScripten, and 287 of 325 files from Ada runtime system compiled. But in Asm.js and WebAssembly there is no relaxed alignment like in x86, so it should be expressed in config somehow, and if I don't understand the meaning of configuration variables, that is harder to achieve.

Post has shared content

Progress! It has taken a while, but I am once again making some progress toward my goals at Ada creations. In my endeavor to make my own custom scripting language I have a problem: I don't know enough to plan the implementation of piping and redirection of standord out/standard error.

Does anyone know if calling Set_Error or Set_Output from within a task will affect only the task?

While inferior, I am still considering running all input and output through the script runner instead of directly interfacing with the kernel. This level of abstraction should make maintenance and cross-platform compatibility better. I am also planning on using the GNAT libraries a lot.

Eventually I want all my mini-programs written in Zsh to be written in Ada, which has all the power needed to do most of the less specialized-in-C activities that Zsh can do. Sizeable programs in Zsh, being a scripting language, get to be very slow, but Ada, with the proper libraries, is almost as simple to write in and much much faster and more capable. I am still learning, though, so I don't know how to fully control the standard input,output, and error of spawns and tasks in a cross-platform way. (I love Sparforte, but the project I am working on is different and more for learning while meeting personal needs). If I have to create my own interface to C or import a C executable object statically I found this much on StackOverflow that may help with the cross platform need:

#include <windows.h>
#include <io.h>
#include <fcntl.h>
#include <cstdio>

int main()
HANDLE h = CreateFile("test.txt", GENERIC_READ | GENERIC_WRITE, 0, 0,
int fd = _open_osfhandle((intptr_t)h, _O_APPEND | _O_RDONLY);
if(fd != -1)
FILE* f = _fdopen(fd, "a+");
if(f != 0)
char rbuffer[256];
memset(rbuffer, 0, 256);
fread(rbuffer, 1, 255, f);
printf("read: %s\n", rbuffer);
fseek(f, 0, SEEK_CUR); // Switch from read to write
const char* wbuffer = " --- Hello World! --- \n";
fwrite(wbuffer, 1, strlen(wbuffer), f);
fclose(f); // Also calls _close()
_close(fd); // Also calls CloseHandle()

Post has attachment

Post has attachment
Mathpaqs release 23-Dec-2016

The main change in this release is in the Copulas package.
It is now possible to use a vector of pseudo-random generators, one for each dimension.
This way, each independent dimension has a reproducible sequence when using a fixed seed.
Then, results can be reproduced even if a dimension is added or removed.

Post has attachment
# Dec2016 Tux (the penguin) avatar in AdaVenture

## A Portable Avatar Using Shaders

* This is a brief description of a DIY, portable, non-proprietary, and open-source-friendly method to program an avatar in any programming language. This example uses Ada.

* This type of shader-based avatar encapsulates the details of avatar shape, color, and movement within GLSL shaders and a related code object. The object, avatarobj.adb, is an Ada package used to define an initial collection of cubelets, and a mapping of a segmented texture image onto the cubelets.

* The inputs include uniforms for time, position, and attitude. The shaders then offload the realtime computational burdens onto the graphics processor.

* Obviously, this example implementation is minimal, yet instructive. Data that defines the shape and color, as well as the uniforms and functions that define behavior, reside completely within the object and the shaders. This data can ultimately be as detailed and refined as your imagination permits. And any refinements made are not obfuscated in some esoteric or proprietary format with a limited audience, but remain fully portable and easily enhanced by most any developer using mainstream programming languages.

* My preferred approach would have been to completely define the avatar within the shaders alone. Just look at the creatures in ( But alas, I am yet too unskilled at GLSL to make this work.

* In my example, the texture object is a cube with radius one that is defined in 3 parts. The upper half maps to the main body. The lower half is divided into left and right "cubelets" that are mapped to feet. The image used for the texture also has 3 parts that map to the appropriate piece of the texture object.

* The result is an utterly portable avatar defined by an image and 4 text files:
* texture object body, avatarobj.adb
* texture object spec,
* vertex shader, avatarobj.vs
* fragment shader, avatarobj.fs
* texture image, blkpng.png

* Interfacing game code with such an avatar is very simple. Essentially you need only pass the required uniform values prior to drawing.

* Of course one still needs a decent camera positioning and pointing policy within the game code in order to fully appreciate and exhibit the avatar.

* Get the details and full source code at:, but please note that this avatar was incidental to my game and is a work-in-progress. It was not designed as a tutorial.


Post has attachment
Wait while more posts are being loaded