@Samurai_Crow
Exactly as origami said - any software that is compiled for it. The project I'm working on is a set of libraries implementing an API very similar to AROS/AmigaOS, trying to keep the compatibility where possible but also breaking it without looking back if necessary. The project is far from ready yet, I have only few bits and pieces working together: exec.library with memory management, thread creation, process spawning, message passing, bits of utility and dos.library (path resolver, assigns etc), master process maintaining public message ports. Basics such as a way libraries are built are already there, too.
On ARIX every library is a .so library, but the ARIX ones are different since they need to expose basically only one symbol - the LVO containing also bits of library description (name, version). They can be opened using the exec.library/OpenLibrary call or may be resolved during startup by ld-linux (eventually to be replaced in future by my own solution). Any application can also just link the typical linux libraries if necessary. Actually an ARIX executable could be theoretically any linux executable - this is an idea to play with in the future though.
On ARIX every task/process is linux process with separate address space. A process can of course start several threads if necessary. The IPC can be done using message ports though, but there are some slight differences. The MessagePorts are identified not by a pointer to it (it is meaningless when every process lives in separate address space) but rather by uuid. So, in order to send message to a port you need to know the uuid. Messages are passed by value, not by pointer, which means they need to be copied between processes and need to be discarded after being used. Sending a single message involves one single system call. Messages are also allowed to transfer additional payload such as linux file descriptors, which means other ways of IPC such as shared memory areas are still feasible.
Yes, the project resides mostly in my mind, but once it stabilises enough I will write some docs. The source is not hidden though (btw. it's not APL but rather MPL2.0) and if someone looks for it, he will find it
BTW, source code of one tiny test in ARIX looks like this:
#include <exec/libraries.h>
#include <exec/types.h>
#include <exec/memory.h>
#include <proto/exec.h>
#include <proto/debug.h>
#include <stdarg.h>
#include <stdio.h>
static const char __attribute__((used)) version[] = "\0$VER: DebugTest 60.0 " VERSION_STRING_DATE;
struct Library *DebugBase = NULL;
static inline void Bug(const char *format, ...)
{
va_list args;
va_start(args, format);
VBug(format, args);
va_end(args);
}
int main(int argc, char **argv)
{
(void)argc;
(void)argv;
// Use c lib's printf. We are allowed to do that.
printf("debug.library test\n");
printf("SysBase = %p\n", (void *)ExecBase);
void *buffer = AllocVec(100, MEMF_CLEAR);
printf("AllocMem returned %p\n", buffer);
void *buffer3 = AllocVec(100, MEMF_CLEAR);
printf("AllocMem returned %p\n", buffer3);
void *buffer2 = AllocVecAligned(240000, 262144, MEMF_CLEAR);
printf("AllocMemAligned returned %p\n", buffer2);
FreeVec(buffer);
FreeVec(buffer2);
FreeVec(buffer3);
DebugBase = OpenLibrary("debug.library", 0);
printf("After attempting to open debug.library\nDebugBase = %p\n", (void *)DebugBase);
Bug("Hello, world!\n");
CloseLibrary(DebugBase);
return 0;
}
